hydra-wasm (empty) → 0.17.0

raw patch · 8 files changed

+3924/−0 lines, 8 filesdep +basedep +containersdep +hydra-kernel

Dependencies added: base, containers, hydra-kernel, scientific

Files

• CHANGELOG.md +1372/−0
• LICENSE +201/−0
• NOTICE +3/−0
• hydra-wasm.cabal +43/−0
• src/main/haskell/Hydra/Wasm/Coder.hs +980/−0
• src/main/haskell/Hydra/Wasm/Language.hs +173/−0
• src/main/haskell/Hydra/Wasm/Serde.hs +551/−0
• src/main/haskell/Hydra/Wasm/Syntax.hs +601/−0

@@ -0,0 +1,1372 @@+# Hydra changelog++All notable changes to the Hydra project are documented in this file.++This changelog tracks changes across all Hydra implementations+(Haskell, Java, Python, Scala, TypeScript, Clojure, Common Lisp, Emacs Lisp, Scheme)+and supporting infrastructure.++The format is inspired by [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)+and [Apache TinkerPop](https://github.com/apache/tinkerpop/blob/master/CHANGELOG.asciidoc).++Pre-1.0 versions are listed below.+Untagged versions correspond to in-repository version bumps that were not pushed as Git tags or Hackage releases;+they are documented here for completeness.++---++## [0.17.0] - 2026-07-01++Major themes: first-class support for effects and I/O in the kernel, TypeScript and+Scala reaching publishable parity with the other hosts, and continued maturation of+the published-host build model.++### Highlights++- **Effects and I/O** ([#286](https://github.com/CategoricalData/hydra/issues/286),+  [#288](https://github.com/CategoricalData/hydra/issues/288),+  [#494](https://github.com/CategoricalData/hydra/issues/494)): a new `effect` variant+  on `hydra.core.Type` for representing effectful computations; new kernel modules+  `hydra.file` (`FilePath`, `FileType`, `FileStatus`, `FileExtension`), `hydra.time`+  (`Timespec`), and `hydra.error.file`; new primitive libraries `hydra.lib.effects`,+  `hydra.lib.files`, and `hydra.lib.text` with byte-level I/O; and a new+  `EffectfulTestCase` mechanism so the common test suite can exercise effectful+  primitives across hosts.+- **TypeScript is a complete implementation**+  ([#462](https://github.com/CategoricalData/hydra/issues/462)): self-hosts and passes+  the common test suite, with a per-package npm publish pipeline+  ([#492](https://github.com/CategoricalData/hydra/issues/492)).+- **Scala publishing**: per-package Maven Central publish infrastructure+  ([#491](https://github.com/CategoricalData/hydra/issues/491)).+- **Published-host build model**: published mode now compiles the kernel from the+  co-generated `dist/haskell` rather than Hackage, removing the need for a+  `haskell=local` shim ([#500](https://github.com/CategoricalData/hydra/issues/500));+  the oil-and-water principle and cold-build workflow for `dist/haskell` are documented+  ([#376](https://github.com/CategoricalData/hydra/issues/376)).+- **Kernel hygiene**: `uniqueLabel` (apostrophe suffixes) replaced by `chooseUniqueLabel`+  (numeric suffixes) in `hydra.names`+  ([#436](https://github.com/CategoricalData/hydra/issues/436)).++### Implementations++Eight hosts self-host and pass the common test suite across five families: Haskell,+Java, Python, Scala, and the four Lisp dialects (Clojure, Common Lisp, Scheme, Emacs+Lisp), with TypeScript now joining as a complete host/target. Go remains a "head bud"+(the coder still has emission bugs and the head's runtime is largely placeholder; it+does not yet host the test suite).++### New Features++- Translingual cross-reference convention for `doc` strings: doc-escape tags render to+  each host's native doc syntax (Javadoc, Haddock, Sphinx, TSDoc)+  ([#433](https://github.com/CategoricalData/hydra/issues/433)).+- Neo4j JSON-artifact validation demo, exercised across Java, Python, Haskell, and+  TypeScript ([#510](https://github.com/CategoricalData/hydra/issues/510)).++### Improvements++- The Java/Maven publish set now covers every official Hydra target language, one coder+  package per implementation family+  ([#468](https://github.com/CategoricalData/hydra/issues/468)).+- JVM Maven artifact groups are bifurcated to `net.fortytwo.hydra.java` and+  `net.fortytwo.hydra.scala`, so the Java and Scala (and future Clojure) publish sets+  never collide on coordinates+  ([#519](https://github.com/CategoricalData/hydra/issues/519)).+- Host-specific third-party integrations (the former `bindings/` tree) are folded into+  `overlay/`, unifying hand-written host-native source under one tree+  ([#511](https://github.com/CategoricalData/hydra/issues/511)).+- The coder de-parameterizes context and error types, simplifying generated coder+  signatures ([#518](https://github.com/CategoricalData/hydra/issues/518)).+- TypeScript-to-Java generation now emits the `hydra.lib.*` aggregate namespace+  interfaces (`Maps`, `Strings`, etc.)+  ([#499](https://github.com/CategoricalData/hydra/issues/499)).++---++## [0.16.1] - 2026-06-16++Major themes: the first release built by bootstrapping from previously published+packages, the first full 9 × 9 cross-implementation bootstrapping sweep, and+published-package self-containment fixes for the artifacts that bootstrap rests on.++### Highlights++- **Bootstrap from published packages**: the build links the published 0.16.0 hosts+  (Hackage / Maven Central / PyPI) and uses them to build the next version of Hydra,+  resting on 0.16.0's forward-compatibility guarantees — the published-host consume+  model with a `--local-host` shim, used for the first time in a release+  ([#370](https://github.com/CategoricalData/hydra/issues/370)). 0.16.1 still builds+  against **local** Haskell and Python hosts (`hostOverrides`), because the published+  0.16.0 artifacts it would otherwise consume are the very ones being repaired below.+- **First full 9 × 9 bootstrapping sweep** — every implementation generating every+  other; dozens of cross-host issues surfaced and fixed+  ([#409](https://github.com/CategoricalData/hydra/issues/409), ongoing).+- **Published-package self-containment**: relocate each host's hand-written runtime+  into `overlay/<lang>/hydra-kernel/` so it ships inside the published `hydra-kernel`+  artifact — Python `hydra.python.util` into the wheel+  ([#461](https://github.com/CategoricalData/hydra/issues/461),+  [#472](https://github.com/CategoricalData/hydra/issues/472)) and the Haskell+  authoring DSL + `Libraries`/`Terms` into the sdist+  ([#473](https://github.com/CategoricalData/hydra/issues/473)). Generalized to a+  uniform `overlay/ = transform(packages) + copy(overlay)` model across all hosts+  ([#434](https://github.com/CategoricalData/hydra/issues/434)).+- **Kernel self-containment via generated `hydra.lib.*` registries**: primitive+  names are derived from generated `PrimitiveDefinition` def-modules rather than+  hand-written name strings, in every host+  ([#473](https://github.com/CategoricalData/hydra/issues/473)).+- **In-memory encode/decode synthesis**: derived `hydra.{encode,decode}.*` modules+  are synthesized at build time and excluded from `dist/`, with the synthesizer (not+  inference) as the authority for their annotations+  ([#448](https://github.com/CategoricalData/hydra/issues/448),+  [#476](https://github.com/CategoricalData/hydra/issues/476)).+- **Release hardening**: Apache source-release compliance (signed source archive,+  LICENSE/NOTICE bundling, KEYS) ([#441](https://github.com/CategoricalData/hydra/issues/441)),+  per-package publish orchestrators ([#449](https://github.com/CategoricalData/hydra/issues/449)),+  and packaging-boundary verification gated in CI and at publish time+  ([#472](https://github.com/CategoricalData/hydra/issues/472)).++### New features++- Published-host consume model wired through `bin/sync.sh` for all three hosts+  (`--published-host` default, `--local-host` shim), with the version basis keyed+  off `hydra.json` and the `VERSION` file retired+  ([#370](https://github.com/CategoricalData/hydra/issues/370),+  [#347](https://github.com/CategoricalData/hydra/issues/347)).+- Java and Python coder DSL sources made the sole source of truth; the legacy+  Haskell DSL copies were deleted and cross-package references resolve by name+  ([#346](https://github.com/CategoricalData/hydra/issues/346)).+- Per-host `verify-distribution.sh` self-containment gates (Haskell stages the+  per-package trio and `stack build`s it; Python installs the wheels into an+  isolated venv and imports the kernel modules; Java resolves the published jars+  from an offline consumer), run in CI and as a hard gate in `bin/prepare-release.sh`+  ([#472](https://github.com/CategoricalData/hydra/issues/472)).+- Apache-compliant canonical source archive: signed + checksummed `git archive`+  tarball as the release of record, root `NOTICE`, `KEYS`, and a release-verify CI+  workflow ([#441](https://github.com/CategoricalData/hydra/issues/441)).+- Per-package publish orchestrators `publish-maven.sh` / `publish-pypi.sh` with+  dependency-closure and leaves-first ordering checks+  ([#449](https://github.com/CategoricalData/hydra/issues/449)).+- `hydra-typescript` published as a target Java/Maven + PyPI artifact+  ([#468](https://github.com/CategoricalData/hydra/issues/468)).+- Java coder emits a fluent builder for every generated record type+  ([#465](https://github.com/CategoricalData/hydra/issues/465)); Python coder emits+  per-field `with_<field>` copy-update methods and a fluent builder+  ([#466](https://github.com/CategoricalData/hydra/issues/466)).++### Improvements++- Drop the vestigial `InferenceContext` parameter from the `Primitive.implementation`+  carrier across all hosts; add a graph-free `funT` coder and six `lists` default+  implementations ([#446](https://github.com/CategoricalData/hydra/issues/446)).+- Derive package routing from declared modules; split derived generation into broad+  `mainDslModules` and scoped `mainEncodingModules`+  ([#474](https://github.com/CategoricalData/hydra/issues/474),+  [#475](https://github.com/CategoricalData/hydra/issues/475)).+- Hash JSON content into the per-package input digest; add `digest-check+  refresh-input` and a CI guard that force-regenerates and diffs+  `dist/haskell/hydra-{java,python}` ([#469](https://github.com/CategoricalData/hydra/issues/469)).+- Per-package inference seeds downstream packages from each package's full universe+  while inferring only write targets, fixing `hydra-scala` inference within the CI+  heap budget; declare the `hydra-java` dependency in `hydra-scala` for cold+  ordering ([#470](https://github.com/CategoricalData/hydra/issues/470)).+- Remove the vestigial `Lib/Defaults` registry and empty `defaultLibModules`+  manifest field from all hosts ([#437](https://github.com/CategoricalData/hydra/issues/437)).+- Bundle LICENSE + NOTICE into Java jars (`META-INF`) and Python wheels+  (`dist-info`); declare Apache-2.0 in the Scala build+  ([#441](https://github.com/CategoricalData/hydra/issues/441)).+- Mark lazy parameters on the Scala and Common Lisp primitive registries so eager+  coders thunk correctly ([#453](https://github.com/CategoricalData/hydra/issues/453),+  [#477](https://github.com/CategoricalData/hydra/issues/477),+  [#425](https://github.com/CategoricalData/hydra/issues/425)).+- Staging-loop WIP-commit gate to keep `WIP:` commits off `origin/main`+  ([#466](https://github.com/CategoricalData/hydra/issues/466)).++### Bug fixes++- **Python wheel self-containment**: the `hydra-kernel` wheel now ships+  `hydra.python.util`; gated by a packaging-boundary smoke test in CI and+  `publish-pypi.sh` ([#472](https://github.com/CategoricalData/hydra/issues/472),+  [#461](https://github.com/CategoricalData/hydra/issues/461)).+- **Haskell sdist self-containment**: track the generated `Hydra/Dsl/Terms.hs`+  (was gitignored) so the committed dist exports `ToPrimName`, fixing the cold+  build of the published `hydra-kernel`+  ([#473](https://github.com/CategoricalData/hydra/issues/473)).+- Decode synthesizer threads the fully-applied result type into wrap/record/union+  decoder bodies, so derived decoders emit `DataRow<v>` rather than raw `DataRow`,+  fixing Java and Scala generic decode compilation+  ([#476](https://github.com/CategoricalData/hydra/issues/476)).+- Scala coder emits explicit type arguments for polymorphic non-primitive+  references under a type application (e.g. `requireField`), fixing `Any`-inference+  of curried decoder lambda parameters in `decode/typed`+  ([#434](https://github.com/CategoricalData/hydra/issues/434)).+- Common Lisp and Emacs Lisp: move the hand-written runtime to a dialect-tier path+  so it no longer collides with the generated `hydra.lib.*` def-modules+  ([#434](https://github.com/CategoricalData/hydra/issues/434)).+- Python coder uses the binding `TypeScheme` as the authoritative source for+  parameter and return types ([#488](https://github.com/CategoricalData/hydra/issues/488));+  fixes a duplicate `self` parameter in builders+  ([#478](https://github.com/CategoricalData/hydra/issues/478)).+- Sort term definitions by name in source-file generation so non-Haskell hosts emit+  deterministic alphabetical Haskell output (host-independent of `Maps.elems`+  iteration order) ([#489](https://github.com/CategoricalData/hydra/issues/489)).+- Java coder serializes the `static` method modifier (previously a non-exhaustive+  case) ([#465](https://github.com/CategoricalData/hydra/issues/465)); JavaDoc+  `@link`/`@param` sanitization for strict doclint+  ([#449](https://github.com/CategoricalData/hydra/issues/449)).+- Scala host writer appends a trailing newline when missing, fixing a Lisp-target+  byte mismatch ([#463](https://github.com/CategoricalData/hydra/issues/463)).+- Clojure host: silent wrapping `bigint_to_int{8,16,32,64}` casts per the kernel+  contract ([#483](https://github.com/CategoricalData/hydra/issues/483)); load-order+  and `--kernel-only` filter fixes after kernel renames+  ([#425](https://github.com/CategoricalData/hydra/issues/425)); load the+  `hydra-haskell` baseline for Clojure→Haskell rebuilds+  ([#487](https://github.com/CategoricalData/hydra/issues/487),+  [#460](https://github.com/CategoricalData/hydra/issues/460)).+- Lisp-dialect bootstrap fixes: emit JSON object entries as 2-element `Pair` lists+  rather than dotted cons ([#452](https://github.com/CategoricalData/hydra/issues/452),+  also fixing [#16](https://github.com/CategoricalData/hydra/issues/16)); read+  module names via the correct struct accessor+  ([#471](https://github.com/CategoricalData/hydra/issues/471)); drop stale+  surplus flag arguments from `generate-source-files` calls+  ([#457](https://github.com/CategoricalData/hydra/issues/457),+  [#458](https://github.com/CategoricalData/hydra/issues/458),+  [#464](https://github.com/CategoricalData/hydra/issues/464)); rename eta-wrapped+  projection/unwrap parameters to avoid kernel shadowing+  ([#428](https://github.com/CategoricalData/hydra/issues/428)); propagate a+  non-zero exit from the Scheme test runner on failures and fix Scheme float+  scientific-notation formatting for `|x| >= 1e7`+  ([#447](https://github.com/CategoricalData/hydra/issues/447)).+- Cross-host target dispatch: Common Lisp and Clojure hosts dispatch Scala and+  TypeScript targets ([#482](https://github.com/CategoricalData/hydra/issues/482),+  [#483](https://github.com/CategoricalData/hydra/issues/483)); Scala/Java host+  target-dispatch completions ([#5](https://github.com/CategoricalData/hydra/issues/5),+  [#7](https://github.com/CategoricalData/hydra/issues/7),+  [#17](https://github.com/CategoricalData/hydra/issues/17)).+- TypeScript test runtime reads the kernel JSON field names `body`/`signature`+  (not legacy `term`/`typeScheme`); `lists.nub` dedups by canonical JSON+  ([#485](https://github.com/CategoricalData/hydra/issues/485)).+- Sync robustness: always reassemble `dist/python` under `HYDRA_IN_SYNC` to heal+  partial-dist state ([#480](https://github.com/CategoricalData/hydra/issues/480));+  persist the run dir on bootstrap prep-phase failures+  ([#481](https://github.com/CategoricalData/hydra/issues/481)); complete per-host+  static deps so the bootstrap demo finds fresh dist+  ([#445](https://github.com/CategoricalData/hydra/issues/445)).+- Pin the Python target test interpreter to Python ≥ 3.12+  ([#486](https://github.com/CategoricalData/hydra/issues/486)); Emacs Lisp / Scheme+  target test-runner re-copy robustness+  ([#456](https://github.com/CategoricalData/hydra/issues/456)).+- JavaDoc Pages publish rewritten to build a combined site from the CI-generated+  `dist/java/` artifact, fixing the failure mode where `pages.yml` ran against a+  bare checkout with no `dist/java/` present+  ([#450](https://github.com/CategoricalData/hydra/issues/450)).++### Documentation++- Document the `overlay/` self-containment model, the published-host consume model+  for all three hosts, the `hydra.json` version / host-version basis, and a+  migration-shims recipe ([#434](https://github.com/CategoricalData/hydra/issues/434),+  [#370](https://github.com/CategoricalData/hydra/issues/370),+  [#347](https://github.com/CategoricalData/hydra/issues/347)).+- Document the kernel self-containment / `hydra.lib.*` def-module model and the+  derived-module no-inference invariant+  ([#473](https://github.com/CategoricalData/hydra/issues/473),+  [#466](https://github.com/CategoricalData/hydra/issues/466)); generated Java and+  Python record builders documented in the DSL guides+  ([#465](https://github.com/CategoricalData/hydra/issues/465),+  [#466](https://github.com/CategoricalData/hydra/issues/466)).+- Use absolute GitHub URLs in package READMEs so links resolve when published+  standalone ([#454](https://github.com/CategoricalData/hydra/issues/454)); bundle a+  README into each Python package dir for sdist metadata+  ([#418](https://github.com/CategoricalData/hydra/issues/418)).++---++## [0.16.0] - 2026-06-09++Major themes: primitive-metadata reification, self-hosting coder DSLs with all+eight hosts passing the common test suite, finalized `hydra.packaging`, and a+deep kernel-vocabulary cleanup.++### Highlights++- **`PrimitiveDefinition` and per-namespace registry modules** with host-independent+  specs for every standard-library primitive ([#156](https://github.com/CategoricalData/hydra/issues/156), [#319](https://github.com/CategoricalData/hydra/issues/319)).+- **Self-hosting coder DSLs; all eight hosts pass the common test suite**, including+  the completed TypeScript head ([#344](https://github.com/CategoricalData/hydra/issues/344), [#126](https://github.com/CategoricalData/hydra/issues/126)).+- **Finalized `hydra.packaging`** and a unified `Module.dependencies` field ([#369](https://github.com/CategoricalData/hydra/issues/369), [#354](https://github.com/CategoricalData/hydra/issues/354)).+- **Kernel-vocabulary cleanup**: `maybe`→`optional` across kernel and hosts, plus+  order-preserving JSON objects ([#401](https://github.com/CategoricalData/hydra/issues/401), [#398](https://github.com/CategoricalData/hydra/issues/398)).++### New features++- Reify `PrimitiveDefinition` in `hydra.packaging` with per-namespace `hydra.lib.<sub>` registries ([#156](https://github.com/CategoricalData/hydra/issues/156)).+- Host-independent `comments` specifications for all standard-library primitives ([#319](https://github.com/CategoricalData/hydra/issues/319)).+- Kernel-oriented style checks in `hydra.validate.*` ([#321](https://github.com/CategoricalData/hydra/issues/321), [#351](https://github.com/CategoricalData/hydra/issues/351), [#352](https://github.com/CategoricalData/hydra/issues/352)), on a reshaped validation API ([#320](https://github.com/CategoricalData/hydra/issues/320)).+- Promote the JSON Schema coder to a full DSL coder ([#350](https://github.com/CategoricalData/hydra/issues/350)).+- Transpose coder sources into host-native DSLs for self-hosting ([#344](https://github.com/CategoricalData/hydra/issues/344), [#358](https://github.com/CategoricalData/hydra/issues/358)).+- `Term`-typed annotations replacing `Map<Name, Term>` ([#386](https://github.com/CategoricalData/hydra/issues/386)).+- Language-specific EDSL features on the kernel `Language` ([#233](https://github.com/CategoricalData/hydra/issues/233)).+- Primitive-metadata-driven laziness in eager coders ([#391](https://github.com/CategoricalData/hydra/issues/391)).+- `/test` skill and `bin/test.sh` for target-language test validation ([#387](https://github.com/CategoricalData/hydra/issues/387)).+- Automatic differentiation: a `grad` transform ([#324](https://github.com/CategoricalData/hydra/issues/324)).+- `hydra.show.error.pg` for `InvalidGraphError` ([#374](https://github.com/CategoricalData/hydra/issues/374)).++### Improvements++- Finalize `hydra.packaging`: `Binding`→`TypeDefinition`, `Module`/`Package` `comments`, `moduleName` cleanup ([#369](https://github.com/CategoricalData/hydra/issues/369), [#396](https://github.com/CategoricalData/hydra/issues/396), [#402](https://github.com/CategoricalData/hydra/issues/402), [#404](https://github.com/CategoricalData/hydra/issues/404)).+- Merge `Module.termDependencies`/`typeDependencies` into one `dependencies` field ([#354](https://github.com/CategoricalData/hydra/issues/354)).+- Resolve the `maybe`/`optional` ambiguity across kernel and all hosts ([#401](https://github.com/CategoricalData/hydra/issues/401)).+- Order-preserving JSON objects; order-sensitive `Value` equality ([#398](https://github.com/CategoricalData/hydra/issues/398)).+- Rename `Namespace`→`ModuleName` ([#316](https://github.com/CategoricalData/hydra/issues/316)) and the phantom DSL types to `Typed*` ([#397](https://github.com/CategoricalData/hydra/issues/397)).+- Move from a type-class enum to type-class names ([#275](https://github.com/CategoricalData/hydra/issues/275)).+- Repackage "eval lib" modules as kernel lib modules; promote remaining sources ([#260](https://github.com/CategoricalData/hydra/issues/260), [#355](https://github.com/CategoricalData/hydra/issues/355), [#356](https://github.com/CategoricalData/hydra/issues/356)).+- Reshape `hydra.context` into `InferenceContext` ([#368](https://github.com/CategoricalData/hydra/issues/368)).+- Streamline the Haskell, Java, Python, and Scala syntax models, re-pinning Java to SE 21 and Python to the 3.14 PEG grammar ([#297](https://github.com/CategoricalData/hydra/issues/297)).+- Adopt persistent immutable collections across hosts ([#359](https://github.com/CategoricalData/hydra/issues/359), [#360](https://github.com/CategoricalData/hydra/issues/360), [#361](https://github.com/CategoricalData/hydra/issues/361), [#362](https://github.com/CategoricalData/hydra/issues/362)).+- Migrate underscored kernel definition names to camelCase ([#348](https://github.com/CategoricalData/hydra/issues/348)).+- Tidy qualified/unqualified imports in the Haskell DSL sources ([#308](https://github.com/CategoricalData/hydra/issues/308)).+- Eliminate the `Hydra.Module.Compat` shim ([#315](https://github.com/CategoricalData/hydra/issues/315)).+- Homogenize writer conventions across target languages ([#339](https://github.com/CategoricalData/hydra/issues/339)).+- Disambiguate format-version field naming across JSON metadata ([#412](https://github.com/CategoricalData/hydra/issues/412)).+- Per-package DSL→JSON build with per-package incremental inference ([#381](https://github.com/CategoricalData/hydra/issues/381), [#395](https://github.com/CategoricalData/hydra/issues/395)).+- Prune stale `dist/` outputs; self-heal digests; exclude digests from VCS; reconcile drift; fail loud ([#357](https://github.com/CategoricalData/hydra/issues/357), [#393](https://github.com/CategoricalData/hydra/issues/393), [#405](https://github.com/CategoricalData/hydra/issues/405), [#378](https://github.com/CategoricalData/hydra/issues/378), [#379](https://github.com/CategoricalData/hydra/issues/379), [#392](https://github.com/CategoricalData/hydra/issues/392), [#414](https://github.com/CategoricalData/hydra/issues/414)).+- Accept all valid (host, target) pairs in the generation drivers ([#421](https://github.com/CategoricalData/hydra/issues/421)).+- Move Gradle build infrastructure into `heads/java/`; remove top-level `pixi.toml` ([#384](https://github.com/CategoricalData/hydra/issues/384), [#385](https://github.com/CategoricalData/hydra/issues/385)).+- Eliminate post-generation test patches; fix loader/runner kludges; re-enable test timing ([#307](https://github.com/CategoricalData/hydra/issues/307), [#309](https://github.com/CategoricalData/hydra/issues/309), [#311](https://github.com/CategoricalData/hydra/issues/311)).+- Performance/benchmarks and usability assessments ([#277](https://github.com/CategoricalData/hydra/issues/277), [#283](https://github.com/CategoricalData/hydra/issues/283)).+- Split the Hackage distribution into per-package distributions ([#418](https://github.com/CategoricalData/hydra/issues/418)).++### Bug fixes++- Encode `uint32` JSON literals as numbers, not strings ([#431](https://github.com/CategoricalData/hydra/issues/431)).+- Satisfy or suppress warnings in generated Java ([#349](https://github.com/CategoricalData/hydra/issues/349)).+- Restore JSON parser test cases (polymorphic case handling, ordering fallback) ([#336](https://github.com/CategoricalData/hydra/issues/336)).+- Keep annotations through `termAlternatives`/`typeAlternatives` adaptation ([#353](https://github.com/CategoricalData/hydra/issues/353)).+- Scala host decodes module JSON containing term definitions ([#342](https://github.com/CategoricalData/hydra/issues/342)).+- Java coder: fix exponential `let`-bound `cases` cost ([#372](https://github.com/CategoricalData/hydra/issues/372)) and explicit type args on `PersistentMap.ofEntries` ([#394](https://github.com/CategoricalData/hydra/issues/394)).+- Python-host codegen: drop extra `pyStringToPyStrings` wrapping ([#367](https://github.com/CategoricalData/hydra/issues/367)).+- `escape_literal_char` no longer mangles RDF triples ([#363](https://github.com/CategoricalData/hydra/issues/363)).+- Sync robustness: stale coder JSON, omitted native modules, dead helper, bad source dirs ([#406](https://github.com/CategoricalData/hydra/issues/406), [#400](https://github.com/CategoricalData/hydra/issues/400), [#411](https://github.com/CategoricalData/hydra/issues/411), [#408](https://github.com/CategoricalData/hydra/issues/408)).+- Cross-host self-hosting fixes (Scala, TypeScript, and the four Lisp dialects) ([#422](https://github.com/CategoricalData/hydra/issues/422), [#423](https://github.com/CategoricalData/hydra/issues/423), [#424](https://github.com/CategoricalData/hydra/issues/424), [#429](https://github.com/CategoricalData/hydra/issues/429), [#444](https://github.com/CategoricalData/hydra/issues/444), [#366](https://github.com/CategoricalData/hydra/issues/366), [#389](https://github.com/CategoricalData/hydra/issues/389), [#407](https://github.com/CategoricalData/hydra/issues/407), [#425](https://github.com/CategoricalData/hydra/issues/425), [#426](https://github.com/CategoricalData/hydra/issues/426), [#427](https://github.com/CategoricalData/hydra/issues/427), [#432](https://github.com/CategoricalData/hydra/issues/432), [#438](https://github.com/CategoricalData/hydra/issues/438), [#439](https://github.com/CategoricalData/hydra/issues/439), [#443](https://github.com/CategoricalData/hydra/issues/443)).++### Removed++- Removed the `bigfloat` literal type from `FloatType` and `FloatValue` ([#330](https://github.com/CategoricalData/hydra/issues/330)).+  Arbitrary-precision floating-point values were inconsistently supported+  across host languages (Java/Scala in particular lacked a true IEEE 754+  arbitrary-precision implementation), and nothing in the codebase relied on+  them. `FloatType` and `FloatValue` now have only `float32` and `float64`+  variants. Removed library primitives: `bigfloatToBigint`, `bigfloatToFloat32`,+  `bigfloatToFloat64`, `bigintToBigfloat`, `float32ToBigfloat`,+  `float64ToBigfloat`, `readBigfloat`, `showBigfloat`, `roundBigfloat`. New+  primitives `float32ToFloat64` and `float64ToFloat32` (the latter lossy)+  replace the removed bigfloat-routed conversions.+- Removed `heads/haskell/bin/assemble-hackage-sdist.sh` ([#418](https://github.com/CategoricalData/hydra/issues/418)), the 0.15-era+  bridge that flattened the multi-source-dir Haskell head into one self-contained+  `hydra` sdist. Superseded by the per-package assembler (see Improvements).++### Documentation++- Comprehensive documentation refresh for 0.16 ([#383](https://github.com/CategoricalData/hydra/issues/383))+  spanning nine tracks across READMEs, `docs/`, the wiki, CLAUDE.md, and+  in-source kernel comments.+- New `docs/json-format.md` reference describing the canonical JSON wire format+  (tagged-union duality, optional-field rules, IEEE 754 sentinels, integer+  threshold).+- New wiki pages: `Design` (rationale behind each major choice) and `Inference`+  (HM type inference with class constraints).+- Cross-checked every prose doc against current code; corrected drift in+  primitive-checking sections of `docs/recipes/maintenance.md`, the `Primitive`+  shape in `docs/implementation.md` and `docs/recipes/adding-primitives.md`,+  and the build-system narrative.+- Wove motivation ("the why") through the existing doc surface rather than+  collecting it into separately-titled sidebars; landed an inference-overview+  centerpiece on the wiki ([#377](https://github.com/CategoricalData/hydra/issues/377)).+- Aligned doc vocabulary with the LambdaGraph paper and the literature review+  for the design space Hydra inhabits.+- Net-new READMEs for `packages/hydra-kernel`, `packages/hydra-ext`,+  `packages/hydra-coq`, and `packages/hydra-wasm`; top-level `README.md`+  now carries a canonical packages table.+- Audited and refreshed the Claude surface: CLAUDE.md "Where to look up X"+  table extended with rows for `docs/getting-started.md`, `docs/json-format.md`,+  and the `Design` / `Inference` wiki pages; hard-rules block reordered by+  violation frequency; `claude/pitfalls.md` superseded entries folded into+  `docs/troubleshooting.md` / recipes.+- Project-descriptor strings reviewed and aligned across 24 build / packaging+  files (Hackage synopsis, Maven Central description, PyPI / conda-forge+  classifiers, Hydra-format `package.json` files).+- `docs/index.html` (the GitHub Pages landing page) refreshed with audience+  hops into wiki Concepts / Design, `docs/getting-started.md`, and the GitHub+  repo, plus the full published-artifact list across Hackage, Maven Central,+  PyPI, and conda-forge.+- In-source kernel-code rationale comments added at key Sources sites covering+  injection / pair / either / unit-void duality, error taxonomy, variant+  records, inference-context threading, validation profiles, reduction state,+  lexical filters, name mangling, scoping, variable handling, defaults+  integration, and Tarjan SCC choice rationale. JSON encode/decode modules+  cross-reference `docs/json-format.md`.+- Filed `Primitive.implementation` carrier-simplification follow-up+  ([#446](https://github.com/CategoricalData/hydra/issues/446))+  to drop the unused `InferenceContext` and `Graph` parameters once the+  `Lib/Defaults/` integration ([#437](https://github.com/CategoricalData/hydra/issues/437))+  lands.++---++## [0.15.0] - 2026-04-29++A structural-cleanup release.+The repository is reorganized into a three-tree+`packages/` (DSL sources) / `heads/` (per-host runtime) / `dist/` (generated output)+layout ([#290](https://github.com/CategoricalData/hydra/issues/290)), the kernel is simplified ([#251](https://github.com/CategoricalData/hydra/issues/251), [#292](https://github.com/CategoricalData/hydra/issues/292), [#332](https://github.com/CategoricalData/hydra/issues/332)), and Java + Python now+ship as per-package publishable artifacts on Maven Central / PyPI / conda-forge+([#305](https://github.com/CategoricalData/hydra/issues/305)).+Incremental, content-hash-based caches accelerate the sync pipeline ([#247](https://github.com/CategoricalData/hydra/issues/247)).+Three new generation-only targets — Coq ([#326](https://github.com/CategoricalData/hydra/issues/326)), WebAssembly ([#325](https://github.com/CategoricalData/hydra/issues/325)), and an+automatic-differentiation demo ([#324](https://github.com/CategoricalData/hydra/issues/324)) — are in progress as Claude collaborations.++### Highlights++- **Three-tree repository layout**: `packages/` (DSL), `heads/` (host runtime),+  `dist/` (generated) ([#290](https://github.com/CategoricalData/hydra/issues/290)).+- **Per-package distributions** for Java (4 Maven artifacts) and Python (5 wheels):+  `hydra-kernel`, `hydra-pg`, `hydra-rdf`, `hydra-{java,python}`, plus `hydra-ext`+  on PyPI ([#305](https://github.com/CategoricalData/hydra/issues/305)).+- **Kernel simplifications**: `Function`/`Elimination` removed ([#332](https://github.com/CategoricalData/hydra/issues/332)),+  `FunctionPrimitive` removed ([#251](https://github.com/CategoricalData/hydra/issues/251)), `Hydra.Ext.*` prefix retired ([#331](https://github.com/CategoricalData/hydra/issues/331)),+  `Context` error wrapper gone ([#292](https://github.com/CategoricalData/hydra/issues/292)).+- **Incremental caches** across the sync pipeline; ~70x speedup on no-op resync ([#247](https://github.com/CategoricalData/hydra/issues/247)).+- **JSON kernel format v1** with formal wire-format spec and four-field rename ([#343](https://github.com/CategoricalData/hydra/issues/343)).+- **Three new generation-only targets** (in progress): Coq ([#326](https://github.com/CategoricalData/hydra/issues/326)), WebAssembly ([#325](https://github.com/CategoricalData/hydra/issues/325)),+  automatic-differentiation demo ([#324](https://github.com/CategoricalData/hydra/issues/324)).++### New features++- Per-package distributions ([#305](https://github.com/CategoricalData/hydra/issues/305)): standalone Maven / PyPI / conda-forge builds,+  generated `build.gradle` / `pyproject.toml` per package, transitive dep resolution.+- JSON kernel format v1 ([#343](https://github.com/CategoricalData/hydra/issues/343)): formal spec at `docs/json-format.md`,+  four-field rename to `typeScheme`, `Module` field reorder, `formatVersion` stamp.+- `decimal` literal type in the kernel ([#338](https://github.com/CategoricalData/hydra/issues/338)) across all hosts.+- Type-directed JSON encoder with idiomatic optional encoding ([#314](https://github.com/CategoricalData/hydra/issues/314), [#318](https://github.com/CategoricalData/hydra/issues/318)).+- Incremental type inference plus content-hash caches ([#247](https://github.com/CategoricalData/hydra/issues/247)).+- Coq generation target ([#326](https://github.com/CategoricalData/hydra/issues/326), in progress): `hydra-coq` package, 131/131 `.v` files pass `coqc`.+- WebAssembly target ([#325](https://github.com/CategoricalData/hydra/issues/325), in progress): `hydra-wasm` package, M4 closure mechanism.+- Automatic-differentiation demo ([#324](https://github.com/CategoricalData/hydra/issues/324), in progress): symbolic source-to-source.+- `hydra.show.error` module ([#265](https://github.com/CategoricalData/hydra/issues/265)): consolidated error-message builders.+- `hydra.lib.maybes.toList` primitive ([#257](https://github.com/CategoricalData/hydra/issues/257)).+- NaN / Inf round-tripping through JSON and per-language serdes ([#312](https://github.com/CategoricalData/hydra/issues/312), [#318](https://github.com/CategoricalData/hydra/issues/318), [#330](https://github.com/CategoricalData/hydra/issues/330)).+- Typeclass inference test group ([#274](https://github.com/CategoricalData/hydra/issues/274)).+- Term and type linters ([#232](https://github.com/CategoricalData/hydra/issues/232)).+- Validation for modules and graphs ([#155](https://github.com/CategoricalData/hydra/issues/155)).+- User-defined-function (UDF) support and DSL-vs-primitive overrides+  ([#62](https://github.com/CategoricalData/hydra/issues/62), [#63](https://github.com/CategoricalData/hydra/issues/63), [#102](https://github.com/CategoricalData/hydra/issues/102), [#158](https://github.com/CategoricalData/hydra/issues/158)).+- Stale-source detection across sync entrypoints ([#228](https://github.com/CategoricalData/hydra/issues/228)).++### Improvements++- Sync infrastructure: matrix tool, per-package orchestrator, per-language wrappers ([#290](https://github.com/CategoricalData/hydra/issues/290)).+- TestGraph post-generation patches eliminated; DSL emits `TestEnv` refs directly.+- Minimized standard imports in generated Haskell ([#161](https://github.com/CategoricalData/hydra/issues/161)); improved auto-aliases ([#322](https://github.com/CategoricalData/hydra/issues/322)).+- Removed kernel term dependencies from the interpreter ([#257](https://github.com/CategoricalData/hydra/issues/257)).+- Removed `Graph` and `Context` arguments from primitive implementations ([#266](https://github.com/CategoricalData/hydra/issues/266)).+- Refactored kernel term modules: split rewriting/schemas, renamed show.meta → codegen,+  moved `Coder` to `coders`, merged `extract.helpers` ([#221](https://github.com/CategoricalData/hydra/issues/221)).+- Removed Aeson and HsYAML dependencies; YAML coder moved to `hydra-ext` ([#261](https://github.com/CategoricalData/hydra/issues/261)).+- Lisp recursive let bindings via SCC ([#341](https://github.com/CategoricalData/hydra/issues/341)); parenthesis cleanup ([#84](https://github.com/CategoricalData/hydra/issues/84)).+- Everything-to-everything bootstrapping demo ([#254](https://github.com/CategoricalData/hydra/issues/254)).+- Re-enabled skipped Python tests; `disabledForPython` retired ([#263](https://github.com/CategoricalData/hydra/issues/263)).+- Promoted host-specific code in `packages/` into per-head locations ([#337](https://github.com/CategoricalData/hydra/issues/337)).+- Migrated `hydra.common` Java module out ([#10](https://github.com/CategoricalData/hydra/issues/10)).+- Test infrastructure unification under `UniversalTestCase` ([#246](https://github.com/CategoricalData/hydra/issues/246)).+- Default property graph → RDF mapping ([#296](https://github.com/CategoricalData/hydra/issues/296)).+- 13 unsafe partial primitives replaced with `Maybe`-returning alternatives ([#201](https://github.com/CategoricalData/hydra/issues/201)).+- Java generated code uses standard `java.util` collection interfaces ([#313](https://github.com/CategoricalData/hydra/issues/313)).+- `Term.union` renamed to `Term.inject` ([#334](https://github.com/CategoricalData/hydra/issues/334)).+- Inconsistencies in domain DSLs cleaned up ([#219](https://github.com/CategoricalData/hydra/issues/219)).+- Coder packages moved out of hydra-haskell ([#182](https://github.com/CategoricalData/hydra/issues/182)).+- Java package-naming scheme revised ([#223](https://github.com/CategoricalData/hydra/issues/223)).+- Decimal used (instead of bigfloat) for JSON numbers ([#340](https://github.com/CategoricalData/hydra/issues/340)).+- Hydra kernel moved out of hydra-haskell ([#282](https://github.com/CategoricalData/hydra/issues/282)).++### Bug fixes++- `substInTypeScheme` capture-unsafe substitution under nested forall binders.+- Java `Float64` arithmetic primitives corrected for current `PrimitiveFunction` API.+- Clojure decimal handling: value-based equality, `BigInteger` return from `decimal_to_bigint`.+- Scheme runtime R7RS imports for `sets.scm` / `maps.scm` / `eithers.map_set`.+- Python coder defaults corrected from `Py.Name` to `Py.Expression`.+- Scala host JSON-decode failure on modules containing term definitions ([#342](https://github.com/CategoricalData/hydra/issues/342)).+- Lisp coder mutually-recursive let bindings for Clojure ([#341](https://github.com/CategoricalData/hydra/issues/341)).++### Documentation++- Documentation refresh for the 0.15 packaging restructure ([#290](https://github.com/CategoricalData/hydra/issues/290), [#331](https://github.com/CategoricalData/hydra/issues/331)); CLAUDE.md,+  READMEs, recipes, demos, and seven wiki pages updated.+- Code-generation recipe rewritten for the per-package dist layout ([#282](https://github.com/CategoricalData/hydra/issues/282)).+- New `maintenance.md` recipe consolidates non-source-file scans, stale generated+  detection, design-violation checks, and freshness checks.+- Documentation style guide added at `docs/documentation-style-guide.md`.+- Cross-worktree messaging protocol documented in CLAUDE.md.+- Decimal type documented in the lexicon and per-language READMEs ([#338](https://github.com/CategoricalData/hydra/issues/338)).+- JSON encoding format docs updated for idiomatic optional encoding ([#314](https://github.com/CategoricalData/hydra/issues/314)).++---++## [0.14.1] - 2026-03-30++Patch release.+Regenerates all implementations after a fix to the group eval primitive ([#281](https://github.com/CategoricalData/hydra/issues/281)),+and relocates the property-graph and RDF/SHACL "ext" modules into hydra-java and hydra-python.++### Improvements++- Moved PG, RDF, and SHACL ext modules from hydra-ext into hydra-java and hydra-python.++### Bug fixes++- Group eval primitive fix; all targets regenerated ([#281](https://github.com/CategoricalData/hydra/issues/281)).+- JavaDoc HTML-entity escaping in generated `DestructuringPattern.java`.++---++## [0.14.0] - 2026-03-29++Major release adding four new complete Hydra implementations — Scala ([#273](https://github.com/CategoricalData/hydra/issues/273)),+Clojure ([#278](https://github.com/CategoricalData/hydra/issues/278)), Common Lisp, and Scheme — bringing the total to seven bootstrapping hosts+(plus Emacs Lisp, which passes the test suite but does not yet participate in bootstrapping).+Also includes kernel simplifications, an Avro bidirectional coder ([#301](https://github.com/CategoricalData/hydra/issues/301)),+eval primitives ([#281](https://github.com/CategoricalData/hydra/issues/281)), new demos, and significant performance work on the Scheme host.++### Highlights++- **Four new complete implementations**: Hydra-Scala ([#273](https://github.com/CategoricalData/hydra/issues/273)), Hydra-Clojure ([#278](https://github.com/CategoricalData/hydra/issues/278)),+  Hydra-Common Lisp, and Hydra-Scheme pass the common test suite and can serve as+  bootstrapping hosts.+  The four Lisp dialects share a single coder and serializer.+- **Kernel simplifications**: removed `RowType`/`WrappedType` ([#82](https://github.com/CategoricalData/hydra/issues/82)),+  unified `Graph`/`TypeContext`/`InferenceContext` ([#192](https://github.com/CategoricalData/hydra/issues/192)),+  replaced `Module.elements` with `Module.definitions` ([#214](https://github.com/CategoricalData/hydra/issues/214)),+  consolidated error types ([#268](https://github.com/CategoricalData/hydra/issues/268)), and promoted all staging modules to DSL sources ([#267](https://github.com/CategoricalData/hydra/issues/267)).+- **Avro bidirectional coder** ([#301](https://github.com/CategoricalData/hydra/issues/301)) with property graph pipeline demo.+- **Scheme bootstrap performance**: 58 minutes → 5.7 minutes via O(1) vhash data structures+  and IEEE 754 float precision fixes.++### Breaking changes++- Removed legacy adapter framework; replaced by the staging-promoted variant ([#236](https://github.com/CategoricalData/hydra/issues/236), [#295](https://github.com/CategoricalData/hydra/issues/295)).+- Replaced legacy Flow monad with Either ([#245](https://github.com/CategoricalData/hydra/issues/245)).+- Removed `Module.elements`; use `Module.definitions` ([#214](https://github.com/CategoricalData/hydra/issues/214)).+- Removed `RowType` and `WrappedType` ([#82](https://github.com/CategoricalData/hydra/issues/82)).+- Renamed `hydra.accessors` to `hydra.paths` ([#271](https://github.com/CategoricalData/hydra/issues/271)).+- Renamed `hydra.tarjan` and merged into `hydra.sorting` ([#220](https://github.com/CategoricalData/hydra/issues/220)).+- Merged `hydra.constraints` into `hydra.query` ([#272](https://github.com/CategoricalData/hydra/issues/272)).+- Moved `hydra.workflow` to hydra-ext ([#270](https://github.com/CategoricalData/hydra/issues/270)).+- Consolidated `hydra.compute` into `hydra.util` ([#269](https://github.com/CategoricalData/hydra/issues/269)).+- Removed `hydra.describe` ([#216](https://github.com/CategoricalData/hydra/issues/216)) and types from `hydra.mantle` ([#217](https://github.com/CategoricalData/hydra/issues/217)).+- Replaced `OtherError` with task-specific error types ([#268](https://github.com/CategoricalData/hydra/issues/268)).+- Java: lowered minimum Java version to 11 ([#249](https://github.com/CategoricalData/hydra/issues/249)).+- Java: `Pair` replaces `Tuple2` ([#252](https://github.com/CategoricalData/hydra/issues/252)); `Comparable` implemented for generated classes ([#131](https://github.com/CategoricalData/hydra/issues/131)).++### New features++- Hydra-Scala ([#273](https://github.com/CategoricalData/hydra/issues/273)): complete implementation, sbt/Scala 3, 3043 tests.+- Hydra-Lisp: Clojure ([#278](https://github.com/CategoricalData/hydra/issues/278)), Common Lisp, Emacs Lisp, Scheme — four dialects,+  one coder. CI workflows for Clojure, Common Lisp, and Scheme.+- Avro bidirectional coder ([#301](https://github.com/CategoricalData/hydra/issues/301)) with demo.+- Eval primitives ([#281](https://github.com/CategoricalData/hydra/issues/281)): Logic, Equality, Math, collections, and Groups.+- Generated DSL modules ([#180](https://github.com/CategoricalData/hydra/issues/180)): `hydra.dsls` generates DSL helpers from type modules.+- New demos: GraphQL+JSON ([#279](https://github.com/CategoricalData/hydra/issues/279)), PG validation ([#284](https://github.com/CategoricalData/hydra/issues/284)), SHACL ([#294](https://github.com/CategoricalData/hydra/issues/294)), Avro+PG.+- Packaging module ([#290](https://github.com/CategoricalData/hydra/issues/290)): `hydra.packaging` with `Package` type and validation.+- New primitives: `lists.foldr` ([#280](https://github.com/CategoricalData/hydra/issues/280)), `maybes.toList`, float rounding ([#264](https://github.com/CategoricalData/hydra/issues/264), [#285](https://github.com/CategoricalData/hydra/issues/285)).+- Cross-language benchmarking suite ([#234](https://github.com/CategoricalData/hydra/issues/234)).+- Limited typeclass inference ([#164](https://github.com/CategoricalData/hydra/issues/164)).+- Standardized validation patterns across modules ([#291](https://github.com/CategoricalData/hydra/issues/291)).++### Improvements++- Promoted all staging modules to DSL sources ([#267](https://github.com/CategoricalData/hydra/issues/267)).+- Removed legacy adapters, JSON/YAML coders, grammar framework ([#236](https://github.com/CategoricalData/hydra/issues/236), [#295](https://github.com/CategoricalData/hydra/issues/295)).+- Java: efficient immutable data structures ([#193](https://github.com/CategoricalData/hydra/issues/193)); flattened term naming.+- Java: hidden specialized collection classes in type-level files ([#313](https://github.com/CategoricalData/hydra/issues/313)).+- Inference error messages improved ([#231](https://github.com/CategoricalData/hydra/issues/231)).+- Combined nested let bindings in the Haskell coder ([#248](https://github.com/CategoricalData/hydra/issues/248)).+- Simplified `hydra.adapt.simple` ([#255](https://github.com/CategoricalData/hydra/issues/255)).+- Removed Haskell operators dependency from tests ([#288](https://github.com/CategoricalData/hydra/issues/288)).+- Regression tests for non-Haskell/Java coders ([#85](https://github.com/CategoricalData/hydra/issues/85)).+- Regex support added ([#293](https://github.com/CategoricalData/hydra/issues/293)).+- `hydra.annotations.isNativeType` revisited ([#214](https://github.com/CategoricalData/hydra/issues/214)).+- Migrated grammar-generated models ([#295](https://github.com/CategoricalData/hydra/issues/295)).+- `<<= -shouldBe-> <<~` operator change ([#276](https://github.com/CategoricalData/hydra/issues/276)).+- Minimize Generation.hs ([#225](https://github.com/CategoricalData/hydra/issues/225)).+- Implemented missing Flows primitives ([#183](https://github.com/CategoricalData/hydra/issues/183)).+- Removed JavaDocs from the repository ([#262](https://github.com/CategoricalData/hydra/issues/262)).+- Floating-point test portability fixes for Linux CI ([#264](https://github.com/CategoricalData/hydra/issues/264), [#285](https://github.com/CategoricalData/hydra/issues/285)).+- Moved YAML coder to hydra-ext ([#224](https://github.com/CategoricalData/hydra/issues/224)).+- Minimized native Python and Java primitives in favor of DSL implementations ([#244](https://github.com/CategoricalData/hydra/issues/244)).+- Removed the `disabledForPython` test tag ([#250](https://github.com/CategoricalData/hydra/issues/250)).++### Release tooling++- 0.14 release tracking ([#304](https://github.com/CategoricalData/hydra/issues/304)).++### Documentation++- Thorough cleanup of user documentation ([#302](https://github.com/CategoricalData/hydra/issues/302), [#303](https://github.com/CategoricalData/hydra/issues/303)).+- Coding style guide added to wiki.+- Updated 'new implementation' recipe with learnings from Clojure head ([#278](https://github.com/CategoricalData/hydra/issues/278)).++---++## [0.13.0] - 2026-02-27++Major release completing Hydra-Python ([#66](https://github.com/CategoricalData/hydra/issues/66)) and Hydra-Java ([#166](https://github.com/CategoricalData/hydra/issues/166)) as self-hosting Hydra implementations+and demonstrating mutual self-hosting across all three languages.+Significant improvements to type inference, type checking, rewriting, and adaptation.+New language features include first-class Either types, typeclass inference, binary data support,+and a native JSON parser/writer.+Comprehensive tooling for cross-implementation bootstrapping+and provisional support for Go, Rust, and JavaScript targets.++### Highlights++- **Mutual self-hosting across three implementations**: Hydra is now fully self-hosting+  in Haskell ([#179](https://github.com/CategoricalData/hydra/issues/179)), Java, and Python, and can cross-generate between every combination+  of host and target language (9 paths total).+- **Hydra-Java is complete** ([#166](https://github.com/CategoricalData/hydra/issues/166)): all kernel and generation tests pass.+- **Hydra-Python is complete** ([#66](https://github.com/CategoricalData/hydra/issues/66)): 100% test parity with Haskell.+- **Language coders promoted into the Hydra kernel** ([#176](https://github.com/CategoricalData/hydra/issues/176)): Haskell, Java, and Python+  coders are now defined as Hydra DSL modules, making them self-hosting.+- **Either type support** ([#210](https://github.com/CategoricalData/hydra/issues/210)) with full inference, checking, and library support.+- **Native JSON parser and writer** ([#188](https://github.com/CategoricalData/hydra/issues/188), [#243](https://github.com/CategoricalData/hydra/issues/243), [#253](https://github.com/CategoricalData/hydra/issues/253)): Hydra's own JSON parser and writer+  replace the Aeson dependency; bootstrap-from-JSON architecture for cross-implementation+  code generation.++### Breaking changes++- Renamed `Optional` to `Maybe` throughout the codebase ([#204](https://github.com/CategoricalData/hydra/issues/204)):+  `hydra.lib.optionals` → `hydra.lib.maybes`; all `optional` variants renamed to `maybe`.+- Removed unlabeled product and sum types; replaced with pair types ([#212](https://github.com/CategoricalData/hydra/issues/212)).+- Renamed `hydra.core.TypedTerm` to `hydra.core.TypeApplicationTerm`.+- Renamed `hydra.json` to `hydra.json.model`.+- Renamed `hydra.lib.maps.remove` to `hydra.lib.maps.delete`.+- Removed deprecated `hydra.decoding` module.+- Removed old `hydra.mantle.Either` type (replaced by core `Either`).+- Removed `hydra.lib.tuples` library.+- Removed C# coder stub (C# syntax model remains).+- DSL syntax migration: removed `OverloadedStrings` for term expressions ([#238](https://github.com/CategoricalData/hydra/issues/238)).+- Removed `Hydra.Dsl.ShorthandTypes` ([#222](https://github.com/CategoricalData/hydra/issues/222)).++### New features++- Self-hosting in Haskell ([#179](https://github.com/CategoricalData/hydra/issues/179)) and full mutual cross-generation (Haskell ↔ Java ↔ Python).+- New bootstrapping demo validating all 9 paths across 249 modules.+- Promoted Haskell, Java, and Python coders from staging code into Hydra DSL sources ([#176](https://github.com/CategoricalData/hydra/issues/176)).+- JSON-as-source-of-truth bootstrapping architecture ([#243](https://github.com/CategoricalData/hydra/issues/243), [#253](https://github.com/CategoricalData/hydra/issues/253)):+  new executables and scripts enabling `bootstrap-from-json` for cross-implementation+  code generation.+- Generated term encoders and decoders replace legacy hand-coded modules ([#47](https://github.com/CategoricalData/hydra/issues/47)).+- Hydra-Python completion ([#66](https://github.com/CategoricalData/hydra/issues/66)): restructured project layout with `src/main` and+  `src/gen-main` ([#191](https://github.com/CategoricalData/hydra/issues/191)); full library implementations including `hydra.lib.flows`;+  `@lru_cache` optimization for nullary bindings; PyPy compatibility.+- Hydra-Java completion ([#166](https://github.com/CategoricalData/hydra/issues/166)): all kernel and generation tests pass; deep changes+  to Java coder; `Lazy` utility class for delayed evaluation; array-type support+  in Java serde; tail-call optimization in the Java coder; `Tuple` implements `Comparable`.+- Either type ([#210](https://github.com/CategoricalData/hydra/issues/210)): `EitherType`, `either` term constructor, `hydra.lib.eithers` library+  with `either`, `map`, `mapList`, `mapMaybe`, `bimap`, `bind`, `fromLeft`, `fromRight`,+  `isLeft`, `isRight`, `lefts`, `rights`, `partitionEithers`.+- Pair type as a core construct ([#211](https://github.com/CategoricalData/hydra/issues/211)).+- Void type ([#237](https://github.com/CategoricalData/hydra/issues/237)): uninhabited `void` type as the dual of `unit`; type-level only.+- Native JSON parser and writer ([#188](https://github.com/CategoricalData/hydra/issues/188), [#242](https://github.com/CategoricalData/hydra/issues/242)):+  bidirectional JSON encoder/decoder; replaces the Aeson dependency;+  cross-checked via a special test runner.+- Typeclass inference ([#164](https://github.com/CategoricalData/hydra/issues/164)):+  type schemes with typeclass constraints via `TypeVariableMetadata`;+  typeclass metadata on primitive definitions; Haskell coder uses typeclass info.+- Binary/`ByteString` support ([#172](https://github.com/CategoricalData/hydra/issues/172)): binary data via `ByteString` instead of `String`;+  Haskell coder uses `Data.ByteString`; new `binaryToBytes` primitive.+- Parser combinators: new `hydra.parsing` module with combinator types and DSL.+- Higher-order primitive interpreter ([#198](https://github.com/CategoricalData/hydra/issues/198)): all primitives are fully interpretable+  across all three implementations; legacy `requiresInterp` tag removed.+- Let hoisting and flattening: hoisting polymorphic let terms;+  refined hoisting for monomorphic bindings inside polymorphic ones;+  more efficient `liftLambdaAboveLet` ([#202](https://github.com/CategoricalData/hydra/issues/202));+  case-statement hoisting ([#241](https://github.com/CategoricalData/hydra/issues/241)); subterm hoisting helpers.+- Provisional language targets: Go ([#65](https://github.com/CategoricalData/hydra/issues/65)), Rust (with experimental type-level coder),+  JavaScript (syntax model, serde, DSL, generated sources), and Java/Python syntax DSLs.+- New adapter framework ([#236](https://github.com/CategoricalData/hydra/issues/236)): all external coders refactored+  (Haskell, YAML, Scala, JSON Schema, C++, PDL, Protobuf, GraphQL).+- Compact labeled records and variants ([#122](https://github.com/CategoricalData/hydra/issues/122)).+- New primitives:+  `hydra.lib.lists.find`, `hydra.lib.lists.partition`,+  `hydra.lib.flows.withDefault`, `hydra.lib.flows.foldl`,+  `hydra.lib.math.{max,min,abs,pred,signum,succ,even,odd}`,+  `hydra.lib.pairs.bimap`, `hydra.lib.eithers.bind`,+  `hydra.lib.literals.binaryToBytes`, complete `readXxx`/`showXxx` families,+  `hydra.lexical.chooseUniqueName`, `neg` renamed to `negate`,+  full floating-point math primitives in Python ([#208](https://github.com/CategoricalData/hydra/issues/208)).+- DeepCore DSL: a layer one level deeper than the Meta DSLs,+  for programs that construct programs that construct terms.+- `typeOf` implementation ([#168](https://github.com/CategoricalData/hydra/issues/168)).+- Implement `Comparable` for generated Java classes ([#131](https://github.com/CategoricalData/hydra/issues/131)); update of Hydra-Java ([#166](https://github.com/CategoricalData/hydra/issues/166)).+- Compact labeled records exploration ([#122](https://github.com/CategoricalData/hydra/issues/122)).+- Comparison primitives without typeclasses ([#187](https://github.com/CategoricalData/hydra/issues/187)).+- Investigated core support for Either and Flow monads ([#200](https://github.com/CategoricalData/hydra/issues/200)).++### Improvements++- Type system:+  - Refactored `hydra.inference` to create new module `hydra.checking`.+  - Inference checks after unification to prevent schema names from being unified+    with inferred type variables.+  - Type application terms preserved when preparing application terms for Python.+  - Sanity-check tuple projection index against arity during inference.+  - Bind lost type variables in term annotations.+  - Made `extendTypeContextForLet` tolerant of untyped bindings.+- Code generation:+  - Python: support for deeply-nested match statements; more complete `let` support;+    Pythonic syntax for polymorphic function definitions; refinements for complex+    case-hoisting scenarios; performance improvements ([#209](https://github.com/CategoricalData/hydra/issues/209), [#239](https://github.com/CategoricalData/hydra/issues/239), [#240](https://github.com/CategoricalData/hydra/issues/240)); inline+    let/case rewriting for Python targets ([#203](https://github.com/CategoricalData/hydra/issues/203)).+  - Java: method declaration style consistent with calling style.+  - Haskell: standardized typeclass names.+  - Increased maximum trace depth to support more complex sources.+- Common test suite promotion: all tests promoted into a shared, implementation-independent+  test kernel ([#213](https://github.com/CategoricalData/hydra/issues/213)).+- Statically-compiled test suite in Haskell ([#207](https://github.com/CategoricalData/hydra/issues/207)).+- Included all Hydra kernel types in test schema ([#205](https://github.com/CategoricalData/hydra/issues/205)).+- Reorganized Haskell DSL definitions; standardized imports.+- Added TODO comments to all unsafe primitives ([#201](https://github.com/CategoricalData/hydra/issues/201)).+- New `rewriteAndFoldTerm` utility for simultaneous rewriting and folding.+- Lexical helper for dereferencing schema types through aliases.+- Made JSON parser lazy with new `lazy` parser combinator.+- More efficient substitution helpers for empty substitutions.+- Precomputed type/inference context in kernel test runner for performance.+- Property graph encoding and decoding modules promoted into DSL.+- `hydra.tabular` and `hydra.pg.graphson` modules promoted into DSL.+- `hydra.show.*` modules generated into Java and Python.+- Aligned epsilon encoding with the LambdaGraph spec ([#89](https://github.com/CategoricalData/hydra/issues/89)).+- Fixed asymmetry of introductions and eliminations ([#86](https://github.com/CategoricalData/hydra/issues/86), [#134](https://github.com/CategoricalData/hydra/issues/134)).+- Minimized inferred type annotations ([#114](https://github.com/CategoricalData/hydra/issues/114)).+- Investigated combining products with records, sums with unions ([#196](https://github.com/CategoricalData/hydra/issues/196), [#212](https://github.com/CategoricalData/hydra/issues/212)).+- Refined type reduction in adapters ([#144](https://github.com/CategoricalData/hydra/issues/144)).+- Investigation of unification issues ([#163](https://github.com/CategoricalData/hydra/issues/163)).+- Refactored RowType ([#82](https://github.com/CategoricalData/hydra/issues/82)).+- LLM-assisted PG schemas and mappings ([#171](https://github.com/CategoricalData/hydra/issues/171)).+- Simplified unit-valued variants in Python ([#206](https://github.com/CategoricalData/hydra/issues/206)).+- Checked for inconsistencies between Term/TTerm and Type/TType DSLs ([#218](https://github.com/CategoricalData/hydra/issues/218)).+- GenPG demo: refactored to support Haskell, Python, and Java; Python runner;+  Java generation; finalized output format.+- Testing: extended test runners for let hoisting (Haskell, Python, Java);+  floating-point precision tests; ordering tests for `hydra.lib.maps`/`hydra.lib.sets`;+  inference tests for inferred System F terms; case-hoisting test cases; new JSON coder tests;+  thorough test cases for all primitives ([#199](https://github.com/CategoricalData/hydra/issues/199)).++### Bug fixes++- Fixed interpreter bugs causing test failures ([#235](https://github.com/CategoricalData/hydra/issues/235)).+- Fixed bug in type checking in connection with dead code.+- Fixed bug in `removeTypesFromTerm`.+- Fixed bug in `typeOfMap`.+- Fixed 32-bit max int value in `hydra.constants`.+- Fixed numeric precision in Python.+- Added `BigDecimal` support and fixed `uint8` (short) support in Java.+- Fixed Haskell coder with respect to imports for binary literals.+- Excluded `Prelude.encodeFloat` and `Prelude.decodeFloat` from generated Haskell+  due to name collisions.+- Fixed consistency issues in Python primitives:+  `hydra.lib.sets.toList`, `hydra.lib.maps.union` (precedence),+  `hydra.lib.strings.lines`, `hydra.lib.strings.readString` (dequoting),+  `hydra.lib.lists.apply`, `hydra.lib.maps.toList`.+- Fixed Haskell type signature of `hydra.lists.span`.+- Fixed issue with eta expansion of typed terms.+- Fixed shadowing issue in generated encoding modules.+- Added missing alternatives in `hydra.rewriting.rewriteTermM`.++### Documentation++- Updated main README with complete implementation status.+- Added Documentation sections to all implementation READMEs.+- Fixed outdated Code-organization.md (Python now uses `src/gen-main`).+- Fixed incorrect code paths in Implementation.md.+- Added Java section to Testing wiki.+- Comprehensive developer recipes in `docs/recipes/`.+- Documentation for tail-call optimization implementation.+- Added Haddock comments to Haskell primitives.+- Created wiki page on the release process ([#194](https://github.com/CategoricalData/hydra/issues/194)).++### Community++- Accepted babeloff's `isTrivialTerm` changes.++---++## [0.12.0] - 2025-08-28++A consolidation release: significant Python progress, kernel-level cleanup,+and a wave of bookkeeping closures for Hydra-Java module ports.++### Breaking changes++- Removed `hydra.decoding` module ([#190](https://github.com/CategoricalData/hydra/issues/190)).+- Flattened dependency tiers; eliminated tier-1, tier-2, tier-3 organization ([#184](https://github.com/CategoricalData/hydra/issues/184)).+- Removed `typed` term variant ([#173](https://github.com/CategoricalData/hydra/issues/173), [#162](https://github.com/CategoricalData/hydra/issues/162)).+- Module naming changes: moved tabular and relational modules into kernel ([#152](https://github.com/CategoricalData/hydra/issues/152)).+- Standardized on uncurried helper functions in term-level DSLs ([#174](https://github.com/CategoricalData/hydra/issues/174)).+- Renamed `hydra.lib.flows.traverseOptional` to `hydra.lib.flows.mapOptional`.+- Eliminated camel-cased namespace parts from the kernel ([#152](https://github.com/CategoricalData/hydra/issues/152)).+- Replaced list and optional eliminations with primitive functions ([#150](https://github.com/CategoricalData/hydra/issues/150)).+- Moved `Hydra.Ext` to hydra-ext ([#178](https://github.com/CategoricalData/hydra/issues/178)); moved 'ext' sources into hydra-ext ([#189](https://github.com/CategoricalData/hydra/issues/189)).++### New features++- Significant progress toward Hydra-Python completion:+  generated all kernel types and terms into Python;+  added `Decimal` support for bigfloat values;+  environment tracking for variable scoping;+  generated `hydra.languages` into Python;+  `__hash__` and `__eq__` on serializable generated classes ([#160](https://github.com/CategoricalData/hydra/issues/160)).+- Designated `unit` term and type variants ([#186](https://github.com/CategoricalData/hydra/issues/186)).+- `hydra.lib.flows.mapElems` and `hydra.lib.flows.mapKeys` utilities.+- Promoted JSON coder into the DSL ([#181](https://github.com/CategoricalData/hydra/issues/181)).+- Promoted JSON utilities into the DSL ([#181](https://github.com/CategoricalData/hydra/issues/181)).+- C# coder ([#139](https://github.com/CategoricalData/hydra/issues/139)).+- GQL model and parser ([#140](https://github.com/CategoricalData/hydra/issues/140)).+- Tabular adapters ([#142](https://github.com/CategoricalData/hydra/issues/142)).+- Type-level C++ coder ([#170](https://github.com/CategoricalData/hydra/issues/170)).+- Variable-types-to-Haskell-typedefs transformation ([#70](https://github.com/CategoricalData/hydra/issues/70)).+- A newline at the end of each generated file ([#154](https://github.com/CategoricalData/hydra/issues/154)).+- Refactor kernel modules and primitives by connectivity ([#177](https://github.com/CategoricalData/hydra/issues/177)).++### Improvements++- Condensed repeated elements in error traces ([#165](https://github.com/CategoricalData/hydra/issues/165)).+- Fixed transitive schema dependencies ([#185](https://github.com/CategoricalData/hydra/issues/185)).+- Improved adapter solution with respect to literals.+- Better handling of type variables in Python coder.+- Enhanced term-level Python generation with proper ordering to minimize forward references.+- Topo-sort helper function for dependency management.+- Updated all Python libraries with latest changes.+- Distinguished between deannotation and detyping of terms.+- Adapted primitives when applying language constraints to a graph.+- Use unqualified names where possible in generated code ([#153](https://github.com/CategoricalData/hydra/issues/153)).+- Eliminated `Data.Graph` (containers) dependency ([#167](https://github.com/CategoricalData/hydra/issues/167)).+- "Close the loop" demonstration ([#175](https://github.com/CategoricalData/hydra/issues/175)).+- Implemented `typeOf` ([#168](https://github.com/CategoricalData/hydra/issues/168)).++### Bug fixes++- Fixed System F terms for records and case statements ([#168](https://github.com/CategoricalData/hydra/issues/168)).+- Fixed issue with transitive type-level module dependencies ([#185](https://github.com/CategoricalData/hydra/issues/185)).+- Corrected handling of variable references in Python application terms.+- Fixed nullary functions in Python (added empty parens).+- Added missing alternatives in `hydra.rewriting.rewriteTermM`.++### Bookkeeping++- Closed long-standing Hydra-Java module-port issues+  ([#9](https://github.com/CategoricalData/hydra/issues/9), [#11](https://github.com/CategoricalData/hydra/issues/11), [#15](https://github.com/CategoricalData/hydra/issues/15), [#16](https://github.com/CategoricalData/hydra/issues/16), [#18](https://github.com/CategoricalData/hydra/issues/18), [#19](https://github.com/CategoricalData/hydra/issues/19), [#20](https://github.com/CategoricalData/hydra/issues/20), [#21](https://github.com/CategoricalData/hydra/issues/21), [#22](https://github.com/CategoricalData/hydra/issues/22), [#23](https://github.com/CategoricalData/hydra/issues/23), [#25](https://github.com/CategoricalData/hydra/issues/25), [#44](https://github.com/CategoricalData/hydra/issues/44), [#45](https://github.com/CategoricalData/hydra/issues/45));+  most of the underlying work shipped in earlier releases.+- Closed Hydra-Java DSL-port issues ([#24](https://github.com/CategoricalData/hydra/issues/24), [#26](https://github.com/CategoricalData/hydra/issues/26), [#27](https://github.com/CategoricalData/hydra/issues/27), [#28](https://github.com/CategoricalData/hydra/issues/28), [#29](https://github.com/CategoricalData/hydra/issues/29)) and+  the Scala/Avro tracking issues ([#77](https://github.com/CategoricalData/hydra/issues/77), [#81](https://github.com/CategoricalData/hydra/issues/81)); these had been resolved+  by earlier releases (Scala in 0.14.0, Avro bidi in 0.14.0).++### Documentation++- Updated Hydra-Haskell README.+- Updated Hydra-Java README with corrected links.+- Updated JavaDocs.++---++## [0.11.0] - 2025-03-16++Untagged in-repository version.+A type-inference rebase release: major restructuring of inference internals+to align with Algorithm W, plus a sweeping removal of explicit type annotations+across the kernel.++### Highlights++- **Inference rebased on Algorithm W** ([#118](https://github.com/CategoricalData/hydra/issues/118)): unify-early strategy ([#146](https://github.com/CategoricalData/hydra/issues/146)),+  infinite-type checks restored ([#116](https://github.com/CategoricalData/hydra/issues/116)), recursive-element inference ([#90](https://github.com/CategoricalData/hydra/issues/90)),+  unified handling of elements and let bindings ([#112](https://github.com/CategoricalData/hydra/issues/112)), minimized manual+  type annotations ([#119](https://github.com/CategoricalData/hydra/issues/119)).+- **`hydra.inference` module** introduced for inference type definitions;+  substitution and unification moved up a level.++### Breaking changes++- Argument order of `Logic.ifElse` changed ([#147](https://github.com/CategoricalData/hydra/issues/147)).++### New features++- Inference test cases promoted into the common test suite ([#148](https://github.com/CategoricalData/hydra/issues/148));+  added "kernel examples" inference tests; more recursion / mutual recursion cases.++### Improvements++- Removed type annotations across all kernel sources ([#119](https://github.com/CategoricalData/hydra/issues/119)).+- Migrated to fully-applied primitive library DSLs ([#157](https://github.com/CategoricalData/hydra/issues/157)).+- Aligned `Graph` and `Element` with `LetBinding` ([#159](https://github.com/CategoricalData/hydra/issues/159)).+- `hydra.core.Unit` recognized by the Haskell coder.+- Refactored inference tests.++### Bug fixes++- Fix for underdetermined type in `hydra.decode`.++---++## [0.10.0] - 2025-02-19++Untagged in-repository version.+Adds Hydra-Python (initial completion), a GraphSON coder,+provisional Hydra-Go support, and dot-separated namespace conventions.++### Highlights++- **Hydra-Python initial completion** ([#80](https://github.com/CategoricalData/hydra/issues/80), [#66](https://github.com/CategoricalData/hydra/issues/66)): Python coder, generated kernel+  modules in Python, and full library implementations across kernel namespaces.+- **GraphSON coder** ([#79](https://github.com/CategoricalData/hydra/issues/79)).+- **Provisional Hydra-Go** ([#65](https://github.com/CategoricalData/hydra/issues/65)).+- **Namespace formatting** standardized to dot-separated form ([#151](https://github.com/CategoricalData/hydra/issues/151)).++### Breaking changes++- All namespaces use dot-separated form ([#151](https://github.com/CategoricalData/hydra/issues/151)).++### New features++- Hydra-Python: Python coder; generated `hydra.coreEncoding`, `hydra.strip`,+  `hydra.literals` and other kernel modules in Python; tuple-expression support;+  updated `hydra.constants` in Python.+- GraphSON coder ([#79](https://github.com/CategoricalData/hydra/issues/79)).+- Provisional Hydra-Go ([#65](https://github.com/CategoricalData/hydra/issues/65)).+- `string-to-char-list` and `char-list-to-string` primitives ([#149](https://github.com/CategoricalData/hydra/issues/149)).+- Restored normalization for generated term variables ([#145](https://github.com/CategoricalData/hydra/issues/145)).++### Improvements++- Re-leveled dependency tiers ([#135](https://github.com/CategoricalData/hydra/issues/135)).+- Updated all Java, Haskell, hydra-ext, and Python primitives to current sources.++---++## [0.9.0] - 2025-01-06++Untagged in-repository version.+Bootstraps Hydra-Python and the JSON Schema coder; introduces a fluent Java DSL for flows.++### Highlights++- **JSON Schema coder** ([#141](https://github.com/CategoricalData/hydra/issues/141)).+- **Python coder scaffold**: serde, language constraints, and generated Haskell+  sources for Python.+- **Fluent-style Java DSL for flows** ([#143](https://github.com/CategoricalData/hydra/issues/143)).++### New features++- JSON Schema coder ([#141](https://github.com/CategoricalData/hydra/issues/141)).+- Python coder scaffold and serde.+- Provisional Python language constraints module.+- Fluent-style Java DSL for flows ([#143](https://github.com/CategoricalData/hydra/issues/143)); moved Flows DSL into `hydra.dsl`.+- New `hydra.coders` DSL.+- New DSL functions for core variants.++### Improvements++- Generalized `Namespaces` so it can be used for languages other than Haskell.+- Local-name-only Python type aliases (the directory tree provides the namespace).+- Coders DSL used to simplify Java language-constraint sources.+- Removed redundant productions in the Python grammar.+- Added unit tests for fluent flows.++### Documentation++- Updated JavaDocs for 0.9.0.++---++## [0.8.1] - 2024-09-24++Patch release.++### Improvements++- Generalized the property graph merging utility to accept type systems other than Hydra Core.++---++## [0.8.0] - 2024-09-09++C# support ([#139](https://github.com/CategoricalData/hydra/issues/139)), Graphviz DOT coder, term accessors, and a small breaking change in Java+to support Spark.++### Breaking changes++- Made `FlowException` serializable for Spark support (may affect existing error handling).++### New features++- C# syntax module based on the Microsoft ANTLR grammar ([#139](https://github.com/CategoricalData/hydra/issues/139)).+- Graphviz DOT coder ([#136](https://github.com/CategoricalData/hydra/issues/136)):+  full support for lambdas and recursive `let` statements;+  compact 'accessor graph' visualization option;+  customizable label styles;+  highlighted let-bound terms; edge labels.+- Term accessor type to facilitate lenses and path-aware transformations.+- OpenGQL grammar and generated Haskell for the OpenGQL model ([#140](https://github.com/CategoricalData/hydra/issues/140)).++### Improvements++- Added `</>` as alternative to `@@` application operator in Haskell DSLs.+- Utilities for working with term accessors.+- More specific exception class for JSON decoding.+- Additional convenience methods on `JsonDecoding.java`.+- Used transitive dependencies in hydra-java and hydra-ext.+- Upgraded ANTLR to address a vulnerability.+- Moved TinkerPop utilities from `hydra/ext/org/apache/tinkerpop` into `hydra/pg`.++---++## [0.7.0] - 2024-08-21++Major refactoring of module organization and namespace management.+Establishes the DNS-style namespace convention in hydra-ext+and lifts property-graph models into a top-level `hydra/pg` namespace.++### Breaking changes++- Namespace reorganization: migrated to DNS-based module naming in hydra-ext ([#138](https://github.com/CategoricalData/hydra/issues/138)):+  `hydra/ext/avro` → `hydra/ext/org/apache/avro`,+  `hydra/ext/graphql` → `hydra/ext/org/graphql`,+  `hydra/ext/yaml` → `hydra/ext/org/yaml`,+  `hydra/ext/json/decoding` → `hydra/ext/org/json/decoding`,+  `hydra/ext/rdf` → `hydra/ext/org/w3/rdf`,+  `hydra/ext/shacl` → `hydra/ext/org/w3/shacl`,+  `hydra/ext/tinkerpop` → `hydra/ext/org/apache/tinkerpop`.+- Property graphs: promoted property graph modules from+  `hydra/ext/org/apache/tinkerpop` to `hydra/pg`.+- Project structure: renamed `hydra-extensions` to `hydra-ext`;+  renamed `hydra/langs` to `hydra/ext` ([#138](https://github.com/CategoricalData/hydra/issues/138));+  made hydra-ext into a Gradle subproject alongside hydra-java;+  added top-level Gradle build.++### Improvements++- Moved TinkerPop modules from hydra-haskell into hydra-ext for better separation.+- Moved miscellaneous models to `Hydra.Ext.Other` ([#138](https://github.com/CategoricalData/hydra/issues/138)).+- Moved XML Schema, SQL, ShEx, and OWL models to hydra-ext.+- Moved KQL, Parquet, and Python modules to hydra-ext.+- Separated JavaDocs for hydra-java and hydra-ext.+- Updated publishing configuration in `build.gradle`.++---++## [0.6.0] - 2024-08-19++Type-system improvements (System F type abstraction/application; eliminated polymorphic+types from Hydra Core), expanded language support (Graphviz DOT model, generated Java+field-name constants), and revamped annotation handling.++### Breaking changes++- Eliminated `InferenceContext` helper type ([#103](https://github.com/CategoricalData/hydra/issues/103)).+- Changed typing environment from `Map Name Type` to `Map Name TypeScheme` in graphs ([#76](https://github.com/CategoricalData/hydra/issues/76)).+- Updated annotations and flows to use `map<Name, Term>` instead of `map<string, Term>` ([#133](https://github.com/CategoricalData/hydra/issues/133)).+- Unified `Name` and `FieldName`; aliased to `string` ([#121](https://github.com/CategoricalData/hydra/issues/121)).+- Renamed `hydra/core.UnitType` to `hydra/core.Unit` ([#123](https://github.com/CategoricalData/hydra/issues/123)).+- Eliminated annotation classes; Hydra has a single built-in notion of annotations ([#113](https://github.com/CategoricalData/hydra/issues/113)).+- Unified the `Nominal` type with `RowType` ([#115](https://github.com/CategoricalData/hydra/issues/115)).+- Removed the `extends` parameter for row types ([#132](https://github.com/CategoricalData/hydra/issues/132)).+- Replaced `hydra/Kv` with `hydra/Annotations` (rename revisited).++### New features++- System F support: `typeAbstraction` and `typeApplication` term constructors.+- Python3 syntax model based on the official Python BNF ([#80](https://github.com/CategoricalData/hydra/issues/80)).+- Graphviz DOT model and initial support ([#136](https://github.com/CategoricalData/hydra/issues/136)).+- Field-name constants generated in Java code generation ([#137](https://github.com/CategoricalData/hydra/issues/137)).+- Provisional Algorithm W implementation in Haskell (originally from @wisnesky), kept for reference.++### Improvements++- Primitive organization: Hydra primitives organized into libraries for namespace management.+- Code generation:+  - Escaped field name constants and `with_` methods in Java coder.+  - Generated field name constants in Java ([#137](https://github.com/CategoricalData/hydra/issues/137)).+  - Avoided duplicated comments in wrapper classes in generated Java.+  - Removed superfluous newtype comments in Haskell coder.+- Updated Delta Parquet model to follow the Java API more closely.+- Enriched OpenCypher features module with the complete list of standard Cypher functions.+- Added convenience methods to `JsonEncoding.java`.+- Restored `Hydra.Inference` subdirectory.+- Allowed arbitrary case for element names ([#7](https://github.com/CategoricalData/hydra/issues/7)).+- Corrected `uint8` representation in Java to `Short` ([#120](https://github.com/CategoricalData/hydra/issues/120)).++### Bug fixes++- Fixed handling of type annotations in term adapters.+- Fixed decoding of encoded terms annotated with a type.+- Corrected encoding of universal types in `showTerm` ([#117](https://github.com/CategoricalData/hydra/issues/117)).++---++## [0.5.3] - 2024-08-06++Patch release.+Preserves order of map key/value pairs and set elements during JSON serialization.++### Bug fixes++- Preserved ordering of key/value pairs and set elements in JSON output.++### New features++- Polymorphic `equal` primitive in Haskell and Java.+- Generated Hydra type definitions together with native instantiations of Hydra types+  in Haskell (a stepping stone toward generated coders, [#47](https://github.com/CategoricalData/hydra/issues/47)).++---++## [0.5.1] - 2024-08-01++Patch release.+Dependency updates and minor improvements following the 0.5.0 Hydra Core overhaul.++### Improvements++- Updated dependencies.++---++## [0.5.0] - 2024-07-26++Untagged in-repository version.+Major Hydra Core overhaul: eliminates polymorphic types in favor of explicit+TypeScheme; consolidates the annotation system; revamps `Let` term encoding.++### Breaking changes++- Eliminated polymorphic types from Hydra Core in Haskell ([#125](https://github.com/CategoricalData/hydra/issues/125)):+  removed type parameters from `hydra/core` types in Hydra-Java; replaced type schemes+  with forall types ([#76](https://github.com/CategoricalData/hydra/issues/76)).+- Revamped core encoding and `Let`: bindings are now a list of+  `(name, term, optional type scheme)` triplets instead of a map.+- Unified typed-term types and moved `TypeScheme` into Hydra Core.+- Eliminated `AnnotationClass`; Hydra has a single built-in notion of annotations now ([#113](https://github.com/CategoricalData/hydra/issues/113)).+- Renamed and refactored phantom-type wrappers ([#128](https://github.com/CategoricalData/hydra/issues/128)); removed deprecated `Reference`+  type from `hydra/phantoms`.+- Removed incomplete support for stream types and stream terms ([#88](https://github.com/CategoricalData/hydra/issues/88)).++### New features++- `LiteralTypes` DSL module so literals can be built independently of terms.+- `Hydra.Minimal` module to facilitate collaboration on Hydra application prototypes.+- `TypeConstraint` type added to the kernel.+- `foldl` primitive in Haskell and Java; DSL uses `foldl` instead of the built-in+  list elimination term by default.++### Improvements++- Improvements to Java and JSON coders; improved untyped JSON coder.+- Pre-order and post-order term-traversal test cases added.+- Refactored type inference tests.+- Restored generated Java (Core through Tier 3) with only a few manual tweaks.+- Element names allow arbitrary case ([#7](https://github.com/CategoricalData/hydra/issues/7)).++---++## [0.4.0] - 2024-07-10++Untagged in-repository version.+Adds null checks to generated Java (breaking, but justified — Hydra-Java disallows nulls),+the Gremlin model, and Protobuf annotation refinements.++### Breaking changes++- Null checks added to constructors and `withXXX()` methods in generated Java;+  null values are no longer permitted in Hydra-Java.+- Removed Java 8 restriction (raised minimum Java version).++### New features++- Gremlin model ([#127](https://github.com/CategoricalData/hydra/issues/127)); generated Haskell for Gremlin.+- `hydra/lib/lists.safeHead` primitive in Haskell (necessary in Java due to eager evaluation).+- Support for Protobuf `deprecated=true` annotation; non-string Protobuf options.+- Java options in generated Protobuf.++### Improvements++- Used `java.util.Objects.requireNonNull` instead of a custom null check in generated Java.+- Added 'automatically generated file' disclaimer to generated Java files.+- Added autogen comments and null checks to (most) generated Java.+- Added necessary schema-level dependencies for built-in modules.+- Added null checks to the Flows DSL in Java.++---++## [0.3.0] - 2024-06-05++Untagged in-repository version.+Adds an OpenCypher parser based on an ANTLR grammar ([#124](https://github.com/CategoricalData/hydra/issues/124)),+a KQL (Kusto Query Language) model and serializer,+a Delta Parquet model,+and an early property graph queries model in the style of Cypher.++### New features++- OpenCypher parser based on the OpenCypher M23 ANTLR grammar ([#124](https://github.com/CategoricalData/hydra/issues/124));+  ANTLR added as a build dependency;+  large Cypher test suite drawn from the Cypher Manual.+- Cypher-to-PG-query transformer (Java; partially implemented).+- Property graph queries DSL and generated property graph query classes in Java.+- Property graph queries model (Cypher / future GQL style).+- KQL (Kusto Query Language) initial model and basic serializer.+- Delta Parquet model with generated sources.++### Improvements++- Java options and `deprecated=true` support in generated Protobuf.+- Convenience methods in Java.++---++## [0.2.0] - 2024-01-10++Hydra-Java 0.2.0 release.+Significant Java tooling and DSL build-out, Protobuf bidirectional coder,+Python3 syntax model ([#80](https://github.com/CategoricalData/hydra/issues/80)), property graph validation ([#100](https://github.com/CategoricalData/hydra/issues/100)),+JSON bidirectional support in Java ([#104](https://github.com/CategoricalData/hydra/issues/104)),+OpenCypher initial model ([#108](https://github.com/CategoricalData/hydra/issues/108)),+Cypher unification, and the start of the typed-DSL story in Haskell.++### New features++- Property graph validation: validator type, optionality on property types,+  customizable id/property handling in the merging adapter, fine-tuned validation,+  comprehensive unit tests in Java ([#100](https://github.com/CategoricalData/hydra/issues/100)).+- Bidirectional JSON serialization/deserialization in Java ([#104](https://github.com/CategoricalData/hydra/issues/104)).+- Checkstyle configuration based on Google style guide ([#111](https://github.com/CategoricalData/hydra/issues/111)).+- Python3 syntax model based on the official Python BNF ([#80](https://github.com/CategoricalData/hydra/issues/80)).+- Initial OpenCypher model and parser scaffold ([#108](https://github.com/CategoricalData/hydra/issues/108)).+- Protobuf coder ([#99](https://github.com/CategoricalData/hydra/issues/99)): type encoder, field numbering, formatting, deprecated annotation,+  Java options, non-string options.+- Adapter framework tolerance of recursive types ([#58](https://github.com/CategoricalData/hydra/issues/58)); default branch for case+  statements ([#60](https://github.com/CategoricalData/hydra/issues/60)).+- Topological sort in type inference ([#67](https://github.com/CategoricalData/hydra/issues/67)).+- `hydra/query` model ([#73](https://github.com/CategoricalData/hydra/issues/73)).+- Records-to-TinkerPop-elements coder ([#64](https://github.com/CategoricalData/hydra/issues/64)).+- Equality primitives for all literal types ([#92](https://github.com/CategoricalData/hydra/issues/92)); polymorphic logic primitives ([#95](https://github.com/CategoricalData/hydra/issues/95)).+- `mapKeys` primitive ([#93](https://github.com/CategoricalData/hydra/issues/93)).+- Tuple support in Java ([#94](https://github.com/CategoricalData/hydra/issues/94)).+- Java 8 as an optional target ([#96](https://github.com/CategoricalData/hydra/issues/96)); optionally generate Java classes as `Serializable` ([#97](https://github.com/CategoricalData/hydra/issues/97)).+- Bidirectional "merged vertex" and "merged edge" coders ([#106](https://github.com/CategoricalData/hydra/issues/106)).+- Nullability and parameterization in the tabular model ([#107](https://github.com/CategoricalData/hydra/issues/107)).+- Term-level / type-level dependency distinction for modules ([#109](https://github.com/CategoricalData/hydra/issues/109)).+- Flatten nested `let` terms for transformation into Java ([#110](https://github.com/CategoricalData/hydra/issues/110)).+- Various `Flow` utilities in Java: `bind3`; convenience methods for consuming results;+  `fromFlow` variants including one that throws.++### Improvements++- Hydra-Java module ports ([#10](https://github.com/CategoricalData/hydra/issues/10), [#12](https://github.com/CategoricalData/hydra/issues/12), [#13](https://github.com/CategoricalData/hydra/issues/13), [#14](https://github.com/CategoricalData/hydra/issues/14), [#17](https://github.com/CategoricalData/hydra/issues/17), [#30](https://github.com/CategoricalData/hydra/issues/30), [#31](https://github.com/CategoricalData/hydra/issues/31), [#32](https://github.com/CategoricalData/hydra/issues/32), [#33](https://github.com/CategoricalData/hydra/issues/33), [#34](https://github.com/CategoricalData/hydra/issues/34), [#35](https://github.com/CategoricalData/hydra/issues/35),+  [#38](https://github.com/CategoricalData/hydra/issues/38), [#39](https://github.com/CategoricalData/hydra/issues/39), [#41](https://github.com/CategoricalData/hydra/issues/41), [#43](https://github.com/CategoricalData/hydra/issues/43), [#48](https://github.com/CategoricalData/hydra/issues/48), [#71](https://github.com/CategoricalData/hydra/issues/71), [#72](https://github.com/CategoricalData/hydra/issues/72), [#75](https://github.com/CategoricalData/hydra/issues/75), [#83](https://github.com/CategoricalData/hydra/issues/83)):+  `Common`, `CoreEncoding`, `CoreLanguage`, `Kernel`, `Flows`, `Lists`, `Literals`,+  `Math`, `Sets`, `Strings`, `Optionals`, `Maps`, `Flows` primitives, `Sets` primitives.+- Common DSLs in Haskell: Flow support ([#68](https://github.com/CategoricalData/hydra/issues/68)), Let support ([#69](https://github.com/CategoricalData/hydra/issues/69)).+- Renamed annotation type parameter `m` to `a` ([#41](https://github.com/CategoricalData/hydra/issues/41)).+- Updated wrapper, element, and variable types ([#75](https://github.com/CategoricalData/hydra/issues/75)).+- Removed `schema` field from `Element` ([#83](https://github.com/CategoricalData/hydra/issues/83)).+- GraphQL coder ([#78](https://github.com/CategoricalData/hydra/issues/78)).+- Code quality:+  - Updated main and test sources to conform to Checkstyle configuration ([#111](https://github.com/CategoricalData/hydra/issues/111)).+  - Extended line-length limit from 100 to 120 characters.+  - Disabled overly restrictive indentation and import-order rules.+  - Disabled `RightCurlyAlone` for compact inline map definitions.+- Streamlined property-graph element merging to unify properties with identical+  keys and types ([#106](https://github.com/CategoricalData/hydra/issues/106)).+- Convenience functions for printing literals and literal types in the Java DSL.+- Minor addition to JSON decoding.+- DSL convenience: alphabetic-case flexibility for element names ([#7](https://github.com/CategoricalData/hydra/issues/7)).++### Bug fixes++- Fixed type annotations for the Sets Java port ([#48](https://github.com/CategoricalData/hydra/issues/48)).+- Various minor fixes during the Java module ports.++---++## [0.1.1] - 2022-12-04++Patch release the same day as 0.1.0.+README polish only.++---++## [0.1.0] - 2022-12-04++First packaged release of Hydra (Hackage).+This release contains the complete foundation of Hydra.++### Core language++- Hydra's core type and data languages (`hydra.core`).+- Core models for graphs and modules.+- Computation model with the `Flow` monad.+- BNF grammars support.+- Phantom types.+- Basic operations on types and terms.++### Type system++- Hindley–Milner-style type inference.+- Type schemes with polymorphism.+- Type/term validation.++### Transformations++- Adapter system: type-to-type rewriting and transformation.+- Coders:+  Haskell coder (types and terms),+  Java coder (types and terms),+  partial Scala coder (terms only),+  Avro coder,+  JSON coder,+  PDL (Pegasus Data Language) coder,+  RDF + SHACL coder,+  YAML coder.++### Language support++- Models for GraphQL, OWL (Web Ontology Language), ShEx (Shape Expressions),+  and TinkerPop-style property graphs.++### Developer tools++- Type-construction DSL and term-construction DSL.+- QuickCheck property-based tests.++### Implementations++- Hydra-Haskell: bootstrapping implementation with full kernel.+- Hydra-Java: Java implementation with mature tooling.++### Community++- Set up the LambdaGraph Discord server ([#2](https://github.com/CategoricalData/hydra/issues/2)).++---++## Contributing++We welcome contributions! Please see:++- [Developer recipes](https://github.com/CategoricalData/hydra/tree/main/docs/recipes)+- [LambdaGraph Discord](https://bit.ly/lg-discord)++## Release process++See the [Release policy](https://github.com/CategoricalData/hydra/wiki/Release-policy)+wiki page and [docs/release-workflow.md](docs/release-workflow.md)+for information on how Hydra releases are versioned, built, and published.

@@ -0,0 +1,201 @@+                                 Apache License+                           Version 2.0, January 2004+                        http://www.apache.org/licenses/++   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION++   1. Definitions.++      "License" shall mean the terms and conditions for use, reproduction,+      and distribution as defined by Sections 1 through 9 of this document.++      "Licensor" shall mean the copyright owner or entity authorized by+      the copyright owner that is granting the License.++      "Legal Entity" shall mean the union of the acting entity and all+      other entities that control, are controlled by, or are under common+      control with that entity. For the purposes of this definition,+      "control" means (i) the power, direct or indirect, to cause the+      direction or management of such entity, whether by contract or+      otherwise, or (ii) ownership of fifty percent (50%) or more of the+      outstanding shares, or (iii) beneficial ownership of such entity.++      "You" (or "Your") shall mean an individual or Legal Entity+      exercising permissions granted by this License.++      "Source" form shall mean the preferred form for making modifications,+      including but not limited to software source code, documentation+      source, and configuration files.++      "Object" form shall mean any form resulting from mechanical+      transformation or translation of a Source form, including but+      not limited to compiled object code, generated documentation,+      and conversions to other media types.++      "Work" shall mean the work of authorship, whether in Source or+      Object form, made available under the License, as indicated by a+      copyright notice that is included in or attached to the work+      (an example is provided in the Appendix below).++      "Derivative Works" shall mean any work, whether in Source or Object+      form, that is based on (or derived from) the Work and for which the+      editorial revisions, annotations, elaborations, or other modifications+      represent, as a whole, an original work of authorship. For the purposes+      of this License, Derivative Works shall not include works that remain+      separable from, or merely link (or bind by name) to the interfaces of,+      the Work and Derivative Works thereof.++      "Contribution" shall mean any work of authorship, including+      the original version of the Work and any modifications or additions+      to that Work or Derivative Works thereof, that is intentionally+      submitted to Licensor for inclusion in the Work by the copyright owner+      or by an individual or Legal Entity authorized to submit on behalf of+      the copyright owner. For the purposes of this definition, "submitted"+      means any form of electronic, verbal, or written communication sent+      to the Licensor or its representatives, including but not limited to+      communication on electronic mailing lists, source code control systems,+      and issue tracking systems that are managed by, or on behalf of, the+      Licensor for the purpose of discussing and improving the Work, but+      excluding communication that is conspicuously marked or otherwise+      designated in writing by the copyright owner as "Not a Contribution."++      "Contributor" shall mean Licensor and any individual or Legal Entity+      on behalf of whom a Contribution has been received by Licensor and+      subsequently incorporated within the Work.++   2. Grant of Copyright License. Subject to the terms and conditions of+      this License, each Contributor hereby grants to You a perpetual,+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable+      copyright license to reproduce, prepare Derivative Works of,+      publicly display, publicly perform, sublicense, and distribute the+      Work and such Derivative Works in Source or Object form.++   3. Grant of Patent License. Subject to the terms and conditions of+      this License, each Contributor hereby grants to You a perpetual,+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable+      (except as stated in this section) patent license to make, have made,+      use, offer to sell, sell, import, and otherwise transfer the Work,+      where such license applies only to those patent claims licensable+      by such Contributor that are necessarily infringed by their+      Contribution(s) alone or by combination of their Contribution(s)+      with the Work to which such Contribution(s) was submitted. If You+      institute patent litigation against any entity (including a+      cross-claim or counterclaim in a lawsuit) alleging that the Work+      or a Contribution incorporated within the Work constitutes direct+      or contributory patent infringement, then any patent licenses+      granted to You under this License for that Work shall terminate+      as of the date such litigation is filed.++   4. Redistribution. You may reproduce and distribute copies of the+      Work or Derivative Works thereof in any medium, with or without+      modifications, and in Source or Object form, provided that You+      meet the following conditions:++      (a) You must give any other recipients of the Work or+          Derivative Works a copy of this License; and++      (b) You must cause any modified files to carry prominent notices+          stating that You changed the files; and++      (c) You must retain, in the Source form of any Derivative Works+          that You distribute, all copyright, patent, trademark, and+          attribution notices from the Source form of the Work,+          excluding those notices that do not pertain to any part of+          the Derivative Works; and++      (d) If the Work includes a "NOTICE" text file as part of its+          distribution, then any Derivative Works that You distribute must+          include a readable copy of the attribution notices contained+          within such NOTICE file, excluding those notices that do not+          pertain to any part of the Derivative Works, in at least one+          of the following places: within a NOTICE text file distributed+          as part of the Derivative Works; within the Source form or+          documentation, if provided along with the Derivative Works; or,+          within a display generated by the Derivative Works, if and+          wherever such third-party notices normally appear. The contents+          of the NOTICE file are for informational purposes only and+          do not modify the License. You may add Your own attribution+          notices within Derivative Works that You distribute, alongside+          or as an addendum to the NOTICE text from the Work, provided+          that such additional attribution notices cannot be construed+          as modifying the License.++      You may add Your own copyright statement to Your modifications and+      may provide additional or different license terms and conditions+      for use, reproduction, or distribution of Your modifications, or+      for any such Derivative Works as a whole, provided Your use,+      reproduction, and distribution of the Work otherwise complies with+      the conditions stated in this License.++   5. Submission of Contributions. Unless You explicitly state otherwise,+      any Contribution intentionally submitted for inclusion in the Work+      by You to the Licensor shall be under the terms and conditions of+      this License, without any additional terms or conditions.+      Notwithstanding the above, nothing herein shall supersede or modify+      the terms of any separate license agreement you may have executed+      with Licensor regarding such Contributions.++   6. Trademarks. This License does not grant permission to use the trade+      names, trademarks, service marks, or product names of the Licensor,+      except as required for reasonable and customary use in describing the+      origin of the Work and reproducing the content of the NOTICE file.++   7. Disclaimer of Warranty. Unless required by applicable law or+      agreed to in writing, Licensor provides the Work (and each+      Contributor provides its Contributions) on an "AS IS" BASIS,+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or+      implied, including, without limitation, any warranties or conditions+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A+      PARTICULAR PURPOSE. You are solely responsible for determining the+      appropriateness of using or redistributing the Work and assume any+      risks associated with Your exercise of permissions under this License.++   8. Limitation of Liability. In no event and under no legal theory,+      whether in tort (including negligence), contract, or otherwise,+      unless required by applicable law (such as deliberate and grossly+      negligent acts) or agreed to in writing, shall any Contributor be+      liable to You for damages, including any direct, indirect, special,+      incidental, or consequential damages of any character arising as a+      result of this License or out of the use or inability to use the+      Work (including but not limited to damages for loss of goodwill,+      work stoppage, computer failure or malfunction, or any and all+      other commercial damages or losses), even if such Contributor+      has been advised of the possibility of such damages.++   9. Accepting Warranty or Additional Liability. While redistributing+      the Work or Derivative Works thereof, You may choose to offer,+      and charge a fee for, acceptance of support, warranty, indemnity,+      or other liability obligations and/or rights consistent with this+      License. However, in accepting such obligations, You may act only+      on Your own behalf and on Your sole responsibility, not on behalf+      of any other Contributor, and only if You agree to indemnify,+      defend, and hold each Contributor harmless for any liability+      incurred by, or claims asserted against, such Contributor by reason+      of your accepting any such warranty or additional liability.++   END OF TERMS AND CONDITIONS++   APPENDIX: How to apply the Apache License to your work.++      To apply the Apache License to your work, attach the following+      boilerplate notice, with the fields enclosed by brackets "[]"+      replaced with your own identifying information. (Don't include+      the brackets!)  The text should be enclosed in the appropriate+      comment syntax for the file format. We also recommend that a+      file or class name and description of purpose be included on the+      same "printed page" as the copyright notice for easier+      identification within third-party archives.++   Copyright [yyyy] [name of copyright owner]++   Licensed under the Apache License, Version 2.0 (the "License");+   you may not use this file except in compliance with the License.+   You may obtain a copy of the License at++       http://www.apache.org/licenses/LICENSE-2.0++   Unless required by applicable law or agreed to in writing, software+   distributed under the License is distributed on an "AS IS" BASIS,+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+   See the License for the specific language governing permissions and+   limitations under the License.

@@ -0,0 +1,3 @@+Hydra+Copyright 2021-2026 The Hydra authors+https://github.com/CategoricalData/hydra

@@ -0,0 +1,43 @@+cabal-version: 1.12++-- This file has been generated from package.yaml by hpack version 0.39.1.+--+-- see: https://github.com/sol/hpack++name:           hydra-wasm+version:        0.17.0+synopsis:       Hydra's WebAssembly coder: emit Wasm 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". WebAssembly support for Hydra+category:       Data+homepage:       https://github.com/CategoricalData/hydra#readme+bug-reports:    https://github.com/CategoricalData/hydra/issues+author:         Joshua Shinavier <josh@fortytwo.net>+maintainer:     Joshua Shinavier <josh@fortytwo.net>+license:        Apache-2.0+license-file:   LICENSE+build-type:     Simple+extra-source-files:+    LICENSE+    NOTICE+    CHANGELOG.md++source-repository head+  type: git+  location: https://github.com/CategoricalData/hydra++library+  exposed-modules:+      Hydra.Wasm.Coder+      Hydra.Wasm.Language+      Hydra.Wasm.Serde+      Hydra.Wasm.Syntax+  other-modules:+      Paths_hydra_wasm+  hs-source-dirs:+      src/main/haskell+  build-depends:+      base >=4.19.0 && <4.22+    , containers >=0.6.7 && <0.8+    , hydra-kernel ==0.17.0+    , scientific >=0.3.7 && <0.4+  default-language: Haskell2010

@@ -0,0 +1,980 @@+-- Note: this is an automatically generated file. Do not edit.+-- | WebAssembly code generator: converts Hydra type and term modules to WAT source code++module Hydra.Wasm.Coder where+import qualified Hydra.Analysis as Analysis+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.File as File+import qualified Hydra.Environment as Environment+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Formatting as Formatting+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Lexical as Lexical+import qualified Hydra.Overlay.Haskell.Lib.Eithers as Eithers+import qualified Hydra.Overlay.Haskell.Lib.Equality as Equality+import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists+import qualified Hydra.Overlay.Haskell.Lib.Literals as Literals+import qualified Hydra.Overlay.Haskell.Lib.Logic as Logic+import qualified Hydra.Overlay.Haskell.Lib.Maps as Maps+import qualified Hydra.Overlay.Haskell.Lib.Math as Math+import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals+import qualified Hydra.Overlay.Haskell.Lib.Pairs as Pairs+import qualified Hydra.Overlay.Haskell.Lib.Sets as Sets+import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings+import qualified Hydra.Names as Names+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Rewriting as Rewriting+import qualified Hydra.Scoping as Scoping+import qualified Hydra.Serialization as Serialization+import qualified Hydra.Strip as Strip+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variables as Variables+import qualified Hydra.Variants as Variants+import qualified Hydra.Wasm.Language as Language+import qualified Hydra.Wasm.Serde as Serde+import qualified Hydra.Wasm.Syntax as Syntax+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+import qualified Data.Set as S+buildFieldOffsets :: Graph.Graph -> M.Map Core.Name [(Core.Name, Int)]+buildFieldOffsets g =++      let recordFieldsOf =+              \t ->+                let stripped = Strip.deannotateType t+                in case stripped of+                  Core.TypeRecord v0 -> Just v0+                  Core.TypeForall v0 ->+                    let innerStripped = Strip.deannotateType (Core.forallTypeBody v0)+                    in case innerStripped of+                      Core.TypeRecord v1 -> Just v1+                      _ -> Nothing+                  _ -> Nothing+          entryFor =+                  \nameSchemePair ->+                    let tname = Pairs.first nameSchemePair+                        tscheme = Pairs.second nameSchemePair+                        tbody = Core.typeSchemeBody tscheme+                        mfields = recordFieldsOf tbody+                    in (Optionals.cases mfields Nothing (\fts ->+                      let namedOffsets =+                              Lists.map (\p ->+                                let i = Pairs.first p+                                    ft = Pairs.second p+                                in (Core.fieldTypeName ft, (Math.mul i 4))) (Lists.zip (Lists.foldl (\acc -> \_f -> Lists.concat2 acc [+                                Lists.length acc]) [] fts) fts)+                      in (Just (tname, namedOffsets))))+          schemaTypesList = Maps.toList (Graph.graphSchemaTypes g)+          entries = Optionals.cat (Lists.map entryFor schemaTypesList)+      in (Maps.fromList entries)+buildFunctionSignatures :: t0 -> Graph.Graph -> [Packaging.TermDefinition] -> M.Map String ([Syntax.ValType], [Syntax.ValType])+buildFunctionSignatures cx g termDefs =++      let toSigEntry =+              \nameAndScheme ->+                let nm = Pairs.first nameAndScheme+                    ts = Pairs.second nameAndScheme+                    snakeName = Formatting.convertCaseCamelToLowerSnake (Core.unName nm)+                    sigEither = extractSignature cx g (Core.typeSchemeBody ts)+                in (Eithers.either (\_err -> Nothing) (\sig -> Just (snakeName, sig)) sigEither)+          primEntries =+                  Optionals.cat (Lists.map (\kv -> toSigEntry (+                    Pairs.first kv,+                    (Scoping.termSignatureToTypeScheme (Packaging.primitiveDefinitionSignature (Graph.primitiveDefinition (Pairs.second kv)))))) (Maps.toList (Graph.graphPrimitives g)))+          boundEntries = Optionals.cat (Lists.map (\kv -> toSigEntry kv) (Maps.toList (Graph.graphBoundTypes g)))+          localEntries =+                  Optionals.cat (Lists.map (\td -> Optionals.bind (Optionals.map Scoping.termSignatureToTypeScheme (Packaging.termDefinitionSignature td)) (\ts -> toSigEntry (Packaging.termDefinitionName td, ts))) termDefs)+      in (Maps.fromList (Lists.concat [+        primEntries,+        boundEntries,+        localEntries]))+buildStringOffsets :: [String] -> (M.Map String Int, Int)+buildStringOffsets strs =++      let step =+              \acc -> \s ->+                let m = Pairs.first acc+                    off = Pairs.second acc+                    len = Strings.length s+                in (Maps.insert s off m, (Math.add off (Math.add 4 len)))+          final = Lists.foldl step (Maps.empty, 1024) strs+          rawEnd = Pairs.second final+          aligned = Math.mul (Optionals.fromOptional 0 (Math.maybeDiv (Math.add rawEnd 15) 16)) 16+      in (Pairs.first final, aligned)+buildVariantIndexes :: Graph.Graph -> M.Map Core.Name [(Core.Name, Int)]+buildVariantIndexes g =++      let unionFieldsOf =+              \t ->+                let stripped = Strip.deannotateType t+                in case stripped of+                  Core.TypeUnion v0 -> Just v0+                  Core.TypeForall v0 ->+                    let innerStripped = Strip.deannotateType (Core.forallTypeBody v0)+                    in case innerStripped of+                      Core.TypeUnion v1 -> Just v1+                      _ -> Nothing+                  _ -> Nothing+          entryFor =+                  \nameSchemePair ->+                    let tname = Pairs.first nameSchemePair+                        tscheme = Pairs.second nameSchemePair+                        tbody = Core.typeSchemeBody tscheme+                        mfields = unionFieldsOf tbody+                    in (Optionals.cases mfields Nothing (\fts ->+                      let namedIndexes =+                              Lists.map (\p ->+                                let i = Pairs.first p+                                    ft = Pairs.second p+                                in (Core.fieldTypeName ft, i)) (Lists.zip (Lists.foldl (\acc -> \_f -> Lists.concat2 acc [+                                Lists.length acc]) [] fts) fts)+                      in (Just (tname, namedIndexes))))+          schemaTypesList = Maps.toList (Graph.graphSchemaTypes g)+          entries = Optionals.cat (Lists.map entryFor schemaTypesList)+      in (Maps.fromList entries)+clampValTypesToI32 :: [t0] -> [Syntax.ValType]+clampValTypesToI32 vts = Lists.map (\_vt -> Syntax.ValTypeI32) vts+collectCallTargets :: [Syntax.Instruction] -> S.Set String+collectCallTargets instrs =+    Lists.foldl (\acc -> \instr -> case instr of+      Syntax.InstructionCall v0 -> Sets.insert v0 acc+      Syntax.InstructionBlock v0 -> Sets.union acc (collectCallTargets (Syntax.blockInstructionBody v0))+      Syntax.InstructionLoop v0 -> Sets.union acc (collectCallTargets (Syntax.blockInstructionBody v0))+      Syntax.InstructionIf v0 -> Sets.union (Sets.union acc (collectCallTargets (Syntax.ifInstructionThen v0))) (collectCallTargets (Syntax.ifInstructionElse v0))+      _ -> acc) Sets.empty instrs+collectInstructionLocals :: [Syntax.Instruction] -> S.Set String+collectInstructionLocals instrs =+    Lists.foldl (\acc -> \instr -> case instr of+      Syntax.InstructionLocalGet v0 -> Sets.insert v0 acc+      Syntax.InstructionLocalSet v0 -> Sets.insert v0 acc+      Syntax.InstructionLocalTee v0 -> Sets.insert v0 acc+      Syntax.InstructionBlock v0 -> Sets.union acc (collectInstructionLocals (Syntax.blockInstructionBody v0))+      Syntax.InstructionLoop v0 -> Sets.union acc (collectInstructionLocals (Syntax.blockInstructionBody v0))+      Syntax.InstructionIf v0 -> Sets.union (Sets.union acc (collectInstructionLocals (Syntax.ifInstructionThen v0))) (collectInstructionLocals (Syntax.ifInstructionElse v0))+      _ -> acc) Sets.empty instrs+collectStrings :: [Packaging.TermDefinition] -> [String]+collectStrings termDefs =++      let collectOne =+              \acc -> \t -> case t of+                Core.TermLiteral v0 -> case v0 of+                  Core.LiteralString v1 -> Sets.insert v1 acc+                  _ -> acc+                _ -> acc+          allStrings =+                  Lists.foldl (\acc -> \td -> Rewriting.foldOverTerm Coders.TraversalOrderPre collectOne acc (Packaging.termDefinitionBody td)) Sets.empty termDefs+      in (Sets.toList allStrings)+encodeApplication :: t0 -> t1 -> M.Map String Int -> M.Map Core.Name [(Core.Name, Int)] -> M.Map Core.Name [(Core.Name, Int)] -> M.Map String ([t2], t3) -> Core.Term -> Either Errors.Error [Syntax.Instruction]+encodeApplication cx g stringOffsets fieldOffsets variantIndexes funcSigs term =++      let gathered = Analysis.gatherArgs term []+          fun = Pairs.first gathered+          args = Pairs.second gathered+          dfun = Strip.deannotateTerm fun+      in (Eithers.bind (Eithers.mapList (\a -> encodeTerm cx g stringOffsets fieldOffsets variantIndexes funcSigs a) args) (\realArgInstrs ->+        let flatRealArgInstrs = Lists.concat realArgInstrs+            droppedArgInstrs = Lists.concat (Lists.map (\ai -> Lists.concat2 ai [+                  Syntax.InstructionDrop]) realArgInstrs)+        in case dfun of+          Core.TermVariable v0 ->+            let rawName = Core.unName v0+                lname = Formatting.convertCaseCamelToLowerSnake rawName+            in (Logic.ifElse (Lists.null (Optionals.fromOptional [] (Lists.maybeTail (Strings.splitOn "." rawName)))) (+              let mFirstArg = Lists.maybeHead args+                  firstArgInstrs =+                          Optionals.cases mFirstArg [+                            Syntax.InstructionConst (Syntax.ConstValueI32 0)] (\_a -> Optionals.fromOptional [] (Lists.maybeHead realArgInstrs))+                  extraArgDropInstrs =+                          Lists.concat (Lists.map (\ai -> Lists.concat2 ai [+                            Syntax.InstructionDrop]) (Lists.drop 1 realArgInstrs))+              in (Right (Lists.concat [+                extraArgDropInstrs,+                [+                  Syntax.InstructionLocalGet lname,+                  (Syntax.InstructionLoad (Syntax.MemoryInstruction {+                    Syntax.memoryInstructionType = Syntax.ValTypeI32,+                    Syntax.memoryInstructionMemArg = Syntax.MemArg {+                      Syntax.memArgOffset = 4,+                      Syntax.memArgAlign = 2}}))],+                firstArgInstrs,+                [+                  Syntax.InstructionLocalGet lname,+                  (Syntax.InstructionLoad (Syntax.MemoryInstruction {+                    Syntax.memoryInstructionType = Syntax.ValTypeI32,+                    Syntax.memoryInstructionMemArg = Syntax.MemArg {+                      Syntax.memArgOffset = 0,+                      Syntax.memArgAlign = 2}})),+                  (Syntax.InstructionCallIndirect (Syntax.TypeUse {+                    Syntax.typeUseIndex = (Just "__closure_1"),+                    Syntax.typeUseParams = [],+                    Syntax.typeUseResults = []}))]]))) (+              let mSig = Maps.lookup lname funcSigs+                  callerArgCount = Lists.length args+                  calleeParamCount = Optionals.cases mSig callerArgCount (\sig -> Lists.length (Pairs.first sig))+                  padCount = Math.sub calleeParamCount callerArgCount+                  padInstrs =+                          Lists.concat (Lists.replicate (Logic.ifElse (Equality.gt padCount 0) padCount 0) [+                            Syntax.InstructionConst (Syntax.ConstValueI32 0)])+              in (Right (Lists.concat [+                flatRealArgInstrs,+                padInstrs,+                [+                  Syntax.InstructionCall lname]]))))+          Core.TermProject v0 -> Optionals.cases (Lists.maybeHead args) (Right [+            Syntax.InstructionConst (Syntax.ConstValueI32 0)]) (\firstArg -> Eithers.bind (encodeTerm cx g stringOffsets fieldOffsets variantIndexes funcSigs firstArg) (\firstArgInstrs -> encodeProjection cx g fieldOffsets v0 firstArgInstrs))+          Core.TermCases v0 -> Optionals.cases (Lists.maybeHead args) (Right [+            Syntax.InstructionConst (Syntax.ConstValueI32 0)]) (\firstArg -> Eithers.bind (encodeTerm cx g stringOffsets fieldOffsets variantIndexes funcSigs firstArg) (\firstArgInstrs -> encodeCases cx g stringOffsets fieldOffsets variantIndexes funcSigs v0 firstArgInstrs))+          Core.TermLambda v0 ->+            let peeled = peelLambdaApp (Core.TermLambda v0) args+                paramNames = Pairs.first peeled+                innerBody = Pairs.second peeled+                bindInstrs =+                        Lists.concat (Lists.map (\np ->+                          let pname = Formatting.convertCaseCamelToLowerSnake (Core.unName (Pairs.first np))+                              argInstrs = Pairs.second np+                          in (Lists.concat2 argInstrs [+                            Syntax.InstructionLocalSet pname])) (Lists.zip paramNames realArgInstrs))+                extraArgInstrs =+                        Lists.concat (Lists.map (\ai -> Lists.concat2 ai [+                          Syntax.InstructionDrop]) (Lists.drop (Lists.length paramNames) realArgInstrs))+            in (Eithers.bind (encodeTerm cx g stringOffsets fieldOffsets variantIndexes funcSigs innerBody) (\bodyInstrs -> Right (Lists.concat [+              bindInstrs,+              extraArgInstrs,+              bodyInstrs])))+          _ -> Eithers.bind (encodeTerm cx g stringOffsets fieldOffsets variantIndexes funcSigs fun) (\funInstrs -> Right (Lists.concat [+            droppedArgInstrs,+            funInstrs,+            [+              Syntax.InstructionDrop,+              (Syntax.InstructionConst (Syntax.ConstValueI32 0))]]))))+encodeCases :: t0 -> t1 -> M.Map String Int -> M.Map Core.Name [(Core.Name, Int)] -> M.Map Core.Name [(Core.Name, Int)] -> M.Map String ([t2], t3) -> Core.CaseStatement -> [Syntax.Instruction] -> Either Errors.Error [Syntax.Instruction]+encodeCases cx g stringOffsets fieldOffsets variantIndexes funcSigs cs scrutineeInstrsRaw =++      let tname = Formatting.convertCaseCamelToLowerSnake (Names.localNameOf (Core.caseStatementTypeName cs))+          caseFields = Core.caseStatementCases cs+          scrutineeInstrs =+                  Logic.ifElse (Lists.null scrutineeInstrsRaw) [+                    Syntax.InstructionConst (Syntax.ConstValueI32 0)] scrutineeInstrsRaw+          prologue =+                  Lists.concat [+                    scrutineeInstrs,+                    [+                      Syntax.InstructionLocalSet "__rec_ptr",+                      (Syntax.InstructionLocalGet "__rec_ptr"),+                      (Syntax.InstructionLoad (Syntax.MemoryInstruction {+                        Syntax.memoryInstructionType = Syntax.ValTypeI32,+                        Syntax.memoryInstructionMemArg = Syntax.MemArg {+                          Syntax.memArgOffset = 4,+                          Syntax.memArgAlign = 2}})),+                      (Syntax.InstructionLocalSet "v"),+                      (Syntax.InstructionLocalGet "__rec_ptr"),+                      (Syntax.InstructionLoad (Syntax.MemoryInstruction {+                        Syntax.memoryInstructionType = Syntax.ValTypeI32,+                        Syntax.memoryInstructionMemArg = Syntax.MemArg {+                          Syntax.memArgOffset = 0,+                          Syntax.memArgAlign = 2}}))]]+      in (Eithers.bind (Eithers.mapList (\cf ->+        let cfname = Formatting.convertCaseCamelToLowerSnake (Core.unName (Core.caseAlternativeName cf))+            cfterm = Core.caseAlternativeHandler cf+        in (Eithers.bind (encodeTerm cx g stringOffsets fieldOffsets variantIndexes funcSigs (Core.TermApplication (Core.Application {+          Core.applicationFunction = cfterm,+          Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))) (\armBody -> Right (cfname, armBody)))) caseFields) (\explicitArms ->+        let defaultArmLabel = "_default"+            mDefault = Core.caseStatementDefault cs+        in (Eithers.bind (Optionals.cases mDefault (Right [+          Syntax.InstructionConst (Syntax.ConstValueI32 0)]) (\defTerm -> encodeTerm cx g stringOffsets fieldOffsets variantIndexes funcSigs defTerm)) (\defaultArmBody ->+          let arms = Lists.concat2 explicitArms [+                (defaultArmLabel, defaultArmBody)]+              explicitLabelForName =+                      \fname -> Optionals.fromOptional defaultArmLabel (Optionals.map Pairs.first (Lists.find (\arm -> Equality.equal (Pairs.first arm) fname) explicitArms))+              typeName = Core.caseStatementTypeName cs+              mUnionVariants = Maps.lookup typeName variantIndexes+              brTableLabels =+                      Optionals.cases mUnionVariants (Lists.map Pairs.first explicitArms) (\variantPairs ->+                        let sorted = Lists.sortOn Pairs.second variantPairs+                        in (Lists.map (\np ->+                          let fieldName = Formatting.convertCaseCamelToLowerSnake (Core.unName (Pairs.first np))+                          in (explicitLabelForName fieldName)) sorted))+              endLabel = Strings.cat2 "end_" tname+              innerDispatch =+                      Lists.concat2 prologue [+                        Syntax.InstructionBrTable (Syntax.BrTableArgs {+                          Syntax.brTableArgsLabels = brTableLabels,+                          Syntax.brTableArgsDefault = defaultArmLabel})]+              dispatch =+                      Lists.foldl (\acc -> \arm ->+                        let label = Pairs.first arm+                            body = Pairs.second arm+                        in (Lists.concat [+                          [+                            Syntax.InstructionBlock (Syntax.BlockInstruction {+                              Syntax.blockInstructionLabel = (Just label),+                              Syntax.blockInstructionBlockType = Syntax.BlockTypeEmpty,+                              Syntax.blockInstructionBody = acc})],+                          body,+                          [+                            Syntax.InstructionBr endLabel]])) innerDispatch arms+          in (Right [+            Syntax.InstructionBlock (Syntax.BlockInstruction {+              Syntax.blockInstructionLabel = (Just endLabel),+              Syntax.blockInstructionBlockType = (Syntax.BlockTypeValue Syntax.ValTypeI32),+              Syntax.blockInstructionBody = dispatch})])))))+encodeLiteral :: Core.Literal -> Syntax.Instruction+encodeLiteral lit =+    case lit of+      Core.LiteralBoolean v0 -> Syntax.InstructionConst (Syntax.ConstValueI32 (Logic.ifElse v0 1 0))+      Core.LiteralString _ -> Syntax.InstructionConst (Syntax.ConstValueI32 0)+      Core.LiteralFloat _ -> Syntax.InstructionConst (Syntax.ConstValueI32 0)+      Core.LiteralInteger v0 -> case v0 of+        Core.IntegerValueInt8 v1 -> Syntax.InstructionConst (Syntax.ConstValueI32 (Literals.bigintToInt32 (Literals.int8ToBigint v1)))+        Core.IntegerValueInt16 v1 -> Syntax.InstructionConst (Syntax.ConstValueI32 (Literals.bigintToInt32 (Literals.int16ToBigint v1)))+        Core.IntegerValueInt32 v1 -> Syntax.InstructionConst (Syntax.ConstValueI32 v1)+        Core.IntegerValueInt64 _ -> Syntax.InstructionConst (Syntax.ConstValueI32 0)+        Core.IntegerValueUint8 v1 -> Syntax.InstructionConst (Syntax.ConstValueI32 (Literals.bigintToInt32 (Literals.uint8ToBigint v1)))+        Core.IntegerValueUint16 v1 -> Syntax.InstructionConst (Syntax.ConstValueI32 (Literals.bigintToInt32 (Literals.uint16ToBigint v1)))+        Core.IntegerValueUint32 v1 -> Syntax.InstructionConst (Syntax.ConstValueI32 (Literals.bigintToInt32 (Literals.uint32ToBigint v1)))+        Core.IntegerValueUint64 _ -> Syntax.InstructionConst (Syntax.ConstValueI32 0)+        Core.IntegerValueBigint _ -> Syntax.InstructionConst (Syntax.ConstValueI32 0)+encodeLiteralType :: Core.LiteralType -> Syntax.ValType+encodeLiteralType lt =+    case lt of+      Core.LiteralTypeBinary -> Syntax.ValTypeI32+      Core.LiteralTypeBoolean -> Syntax.ValTypeI32+      Core.LiteralTypeFloat v0 -> case v0 of+        Core.FloatTypeFloat32 -> Syntax.ValTypeF32+        Core.FloatTypeFloat64 -> Syntax.ValTypeF64+      Core.LiteralTypeInteger v0 -> case v0 of+        Core.IntegerTypeBigint -> Syntax.ValTypeI64+        Core.IntegerTypeInt8 -> Syntax.ValTypeI32+        Core.IntegerTypeInt16 -> Syntax.ValTypeI32+        Core.IntegerTypeInt32 -> Syntax.ValTypeI32+        Core.IntegerTypeInt64 -> Syntax.ValTypeI64+        Core.IntegerTypeUint8 -> Syntax.ValTypeI32+        Core.IntegerTypeUint16 -> Syntax.ValTypeI32+        Core.IntegerTypeUint32 -> Syntax.ValTypeI32+        Core.IntegerTypeUint64 -> Syntax.ValTypeI64+      Core.LiteralTypeString -> Syntax.ValTypeI32+encodeProjection :: t0 -> t1 -> M.Map Core.Name [(Core.Name, Int)] -> Core.Projection -> [Syntax.Instruction] -> Either t2 [Syntax.Instruction]+encodeProjection cx g fieldOffsets proj scrutineeInstrs =++      let typeName = Core.projectionTypeName proj+          fieldName = Core.projectionFieldName proj+          mFields = Maps.lookup typeName fieldOffsets+          mOffset =+                  Optionals.cases mFields Nothing (\pairs ->+                    let matching = Lists.filter (\p -> Equality.equal (Pairs.first p) fieldName) pairs+                    in (Optionals.map Pairs.second (Lists.maybeHead matching)))+      in (Optionals.cases mOffset (Right (Lists.concat [+        scrutineeInstrs,+        (Logic.ifElse (Lists.null scrutineeInstrs) [] [+          Syntax.InstructionDrop]),+        [+          Syntax.InstructionConst (Syntax.ConstValueI32 0)]])) (\off -> Right (Lists.concat [+        Logic.ifElse (Lists.null scrutineeInstrs) [+          Syntax.InstructionConst (Syntax.ConstValueI32 0)] scrutineeInstrs,+        [+          Syntax.InstructionLoad (Syntax.MemoryInstruction {+            Syntax.memoryInstructionType = Syntax.ValTypeI32,+            Syntax.memoryInstructionMemArg = Syntax.MemArg {+              Syntax.memArgOffset = off,+              Syntax.memArgAlign = 2}})]])))+encodeTerm :: t0 -> t1 -> M.Map String Int -> M.Map Core.Name [(Core.Name, Int)] -> M.Map Core.Name [(Core.Name, Int)] -> M.Map String ([t2], t3) -> Core.Term -> Either Errors.Error [Syntax.Instruction]+encodeTerm cx g stringOffsets fieldOffsets variantIndexes funcSigs term =+    case term of+      Core.TermAnnotated v0 -> encodeTerm cx g stringOffsets fieldOffsets variantIndexes funcSigs (Core.annotatedTermBody v0)+      Core.TermApplication v0 -> encodeApplication cx g stringOffsets fieldOffsets variantIndexes funcSigs (Core.TermApplication v0)+      Core.TermCases _ -> Right [+        Syntax.InstructionConst (Syntax.ConstValueI32 0)]+      Core.TermEither v0 ->+        let eitherTag = Eithers.either (\_lv -> 0) (\_rv -> 1) v0+            innerTerm = Eithers.either (\lv -> lv) (\rv -> rv) v0+        in (Eithers.bind (encodeTerm cx g stringOffsets fieldOffsets variantIndexes funcSigs innerTerm) (\payloadInstrs -> Right (Lists.concat [+          [+            Syntax.InstructionConst (Syntax.ConstValueI32 eitherTag)],+          payloadInstrs,+          [+            Syntax.InstructionConst (Syntax.ConstValueI32 8),+            (Syntax.InstructionCall "__alloc"),+            (Syntax.InstructionLocalSet "__rec_ptr"),+            (Syntax.InstructionLocalSet "__rec_scratch"),+            (Syntax.InstructionLocalGet "__rec_ptr"),+            (Syntax.InstructionLocalGet "__rec_scratch"),+            (Syntax.InstructionStore (Syntax.MemoryInstruction {+              Syntax.memoryInstructionType = Syntax.ValTypeI32,+              Syntax.memoryInstructionMemArg = Syntax.MemArg {+                Syntax.memArgOffset = 4,+                Syntax.memArgAlign = 2}})),+            (Syntax.InstructionLocalSet "__rec_scratch"),+            (Syntax.InstructionLocalGet "__rec_ptr"),+            (Syntax.InstructionLocalGet "__rec_scratch"),+            (Syntax.InstructionStore (Syntax.MemoryInstruction {+              Syntax.memoryInstructionType = Syntax.ValTypeI32,+              Syntax.memoryInstructionMemArg = Syntax.MemArg {+                Syntax.memArgOffset = 0,+                Syntax.memArgAlign = 2}})),+            (Syntax.InstructionLocalGet "__rec_ptr")]])))+      Core.TermInject v0 ->+        let typeName = Core.injectionTypeName v0+            field = Core.injectionField v0+            fieldName = Core.fieldName field+            fterm = Core.fieldTerm field+            dterm = Strip.deannotateTerm fterm+            isUnit =+                    case dterm of+                      Core.TermUnit -> True+                      Core.TermRecord v1 -> Lists.null (Core.recordFields v1)+                      _ -> False+            mVariants = Maps.lookup typeName variantIndexes+            tag =+                    Optionals.cases mVariants 0 (\pairs ->+                      let matching = Lists.filter (\p -> Equality.equal (Pairs.first p) fieldName) pairs+                      in (Optionals.cases (Lists.maybeHead matching) 0 (\p -> Pairs.second p)))+        in (Eithers.bind (Logic.ifElse isUnit (Right [+          Syntax.InstructionConst (Syntax.ConstValueI32 0)]) (encodeTerm cx g stringOffsets fieldOffsets variantIndexes funcSigs fterm)) (\payloadInstrs -> Right (Lists.concat [+          [+            Syntax.InstructionConst (Syntax.ConstValueI32 tag)],+          payloadInstrs,+          [+            Syntax.InstructionConst (Syntax.ConstValueI32 8),+            (Syntax.InstructionCall "__alloc"),+            (Syntax.InstructionLocalSet "__rec_ptr"),+            (Syntax.InstructionLocalSet "__rec_scratch"),+            (Syntax.InstructionLocalGet "__rec_ptr"),+            (Syntax.InstructionLocalGet "__rec_scratch"),+            (Syntax.InstructionStore (Syntax.MemoryInstruction {+              Syntax.memoryInstructionType = Syntax.ValTypeI32,+              Syntax.memoryInstructionMemArg = Syntax.MemArg {+                Syntax.memArgOffset = 4,+                Syntax.memArgAlign = 2}})),+            (Syntax.InstructionLocalSet "__rec_scratch"),+            (Syntax.InstructionLocalGet "__rec_ptr"),+            (Syntax.InstructionLocalGet "__rec_scratch"),+            (Syntax.InstructionStore (Syntax.MemoryInstruction {+              Syntax.memoryInstructionType = Syntax.ValTypeI32,+              Syntax.memoryInstructionMemArg = Syntax.MemArg {+                Syntax.memArgOffset = 0,+                Syntax.memArgAlign = 2}})),+            (Syntax.InstructionLocalGet "__rec_ptr")]])))+      Core.TermLambda v0 -> encodeTerm cx g stringOffsets fieldOffsets variantIndexes funcSigs (Core.lambdaBody v0)+      Core.TermLet v0 ->+        let bindings = Core.letBindings v0+            body = Core.letBody v0+        in (Eithers.bind (Eithers.mapList (\b ->+          let bname = Formatting.convertCaseCamelToLowerSnake (Core.unName (Core.bindingName b))+          in (Eithers.bind (encodeTerm cx g stringOffsets fieldOffsets variantIndexes funcSigs (Core.bindingTerm b)) (\bval -> Right (Lists.concat2 bval [+            Syntax.InstructionLocalSet bname])))) bindings) (\bindInstrs -> Eithers.bind (encodeTerm cx g stringOffsets fieldOffsets variantIndexes funcSigs body) (\bodyInstrs -> Right (Lists.concat2 (Lists.concat bindInstrs) bodyInstrs))))+      Core.TermList v0 ->+        let numElems = Lists.length v0+            listSize = Math.mul (Math.add numElems 1) 4+        in (Eithers.bind (Eithers.mapList (\el -> encodeTerm cx g stringOffsets fieldOffsets variantIndexes funcSigs el) v0) (\encodedElems ->+          let allElemInstrs = Lists.concat encodedElems+              allocInstrs =+                      [+                        Syntax.InstructionConst (Syntax.ConstValueI32 listSize),+                        (Syntax.InstructionCall "__alloc"),+                        (Syntax.InstructionLocalSet "__rec_ptr")]+              lengthStoreInstrs =+                      [+                        Syntax.InstructionLocalGet "__rec_ptr",+                        (Syntax.InstructionConst (Syntax.ConstValueI32 numElems)),+                        (Syntax.InstructionStore (Syntax.MemoryInstruction {+                          Syntax.memoryInstructionType = Syntax.ValTypeI32,+                          Syntax.memoryInstructionMemArg = Syntax.MemArg {+                            Syntax.memArgOffset = 0,+                            Syntax.memArgAlign = 2}}))]+              storeInstrs =+                      Lists.concat (Lists.map (\i -> [+                        Syntax.InstructionLocalSet "__rec_scratch",+                        (Syntax.InstructionLocalGet "__rec_ptr"),+                        (Syntax.InstructionLocalGet "__rec_scratch"),+                        (Syntax.InstructionStore (Syntax.MemoryInstruction {+                          Syntax.memoryInstructionType = Syntax.ValTypeI32,+                          Syntax.memoryInstructionMemArg = Syntax.MemArg {+                            Syntax.memArgOffset = (Math.mul (Math.add i 1) 4),+                            Syntax.memArgAlign = 2}}))]) (Lists.foldl (\acc -> \_e -> Lists.cons (Lists.length acc) acc) [] v0))+              finalInstrs = [+                    Syntax.InstructionLocalGet "__rec_ptr"]+          in (Right (Lists.concat [+            allElemInstrs,+            allocInstrs,+            lengthStoreInstrs,+            storeInstrs,+            finalInstrs]))))+      Core.TermLiteral v0 -> case v0 of+        Core.LiteralString v1 -> Optionals.cases (Maps.lookup v1 stringOffsets) (Right [+          Syntax.InstructionConst (Syntax.ConstValueI32 0)]) (\off -> Right [+          Syntax.InstructionConst (Syntax.ConstValueI32 off)])+        _ -> Right [+          encodeLiteral v0]+      Core.TermMap v0 ->+        let mapEntries = Maps.toList v0+            numMapEntries = Lists.length mapEntries+            mapWordCount = Math.add (Math.mul numMapEntries 2) 1+            mapSize = Math.mul mapWordCount 4+        in (Eithers.bind (Eithers.mapList (\kv -> Eithers.bind (encodeTerm cx g stringOffsets fieldOffsets variantIndexes funcSigs (Pairs.first kv)) (\kInstrs -> Eithers.map (\vInstrs -> Lists.concat2 kInstrs vInstrs) (encodeTerm cx g stringOffsets fieldOffsets variantIndexes funcSigs (Pairs.second kv)))) mapEntries) (\encodedMapKVs ->+          let allMapKVInstrs = Lists.concat encodedMapKVs+              mapAllocInstrs =+                      [+                        Syntax.InstructionConst (Syntax.ConstValueI32 mapSize),+                        (Syntax.InstructionCall "__alloc"),+                        (Syntax.InstructionLocalSet "__rec_ptr")]+              mapLengthStoreInstrs =+                      [+                        Syntax.InstructionLocalGet "__rec_ptr",+                        (Syntax.InstructionConst (Syntax.ConstValueI32 numMapEntries)),+                        (Syntax.InstructionStore (Syntax.MemoryInstruction {+                          Syntax.memoryInstructionType = Syntax.ValTypeI32,+                          Syntax.memoryInstructionMemArg = Syntax.MemArg {+                            Syntax.memArgOffset = 0,+                            Syntax.memArgAlign = 2}}))]+              numMapWords = Math.mul numMapEntries 2+              mapReverseIndices = Lists.foldl (\acc -> \_i -> Lists.cons (Lists.length acc) acc) [] (Lists.replicate numMapWords ())+              mapStoreInstrs =+                      Lists.concat (Lists.map (\j -> [+                        Syntax.InstructionLocalSet "__rec_scratch",+                        (Syntax.InstructionLocalGet "__rec_ptr"),+                        (Syntax.InstructionLocalGet "__rec_scratch"),+                        (Syntax.InstructionStore (Syntax.MemoryInstruction {+                          Syntax.memoryInstructionType = Syntax.ValTypeI32,+                          Syntax.memoryInstructionMemArg = Syntax.MemArg {+                            Syntax.memArgOffset = (Math.mul (Math.add j 1) 4),+                            Syntax.memArgAlign = 2}}))]) mapReverseIndices)+              mapFinalInstrs = [+                    Syntax.InstructionLocalGet "__rec_ptr"]+          in (Right (Lists.concat [+            allMapKVInstrs,+            mapAllocInstrs,+            mapLengthStoreInstrs,+            mapStoreInstrs,+            mapFinalInstrs]))))+      Core.TermOptional v0 -> Optionals.cases v0 (Right [+        Syntax.InstructionConst (Syntax.ConstValueI32 0)]) (\val -> encodeTerm cx g stringOffsets fieldOffsets variantIndexes funcSigs val)+      Core.TermPair v0 -> Eithers.bind (encodeTerm cx g stringOffsets fieldOffsets variantIndexes funcSigs (Pairs.first v0)) (\firstInstrs -> Eithers.bind (encodeTerm cx g stringOffsets fieldOffsets variantIndexes funcSigs (Pairs.second v0)) (\secondInstrs -> Right (Lists.concat [+        firstInstrs,+        secondInstrs,+        [+          Syntax.InstructionConst (Syntax.ConstValueI32 8),+          (Syntax.InstructionCall "__alloc"),+          (Syntax.InstructionLocalSet "__rec_ptr"),+          (Syntax.InstructionLocalSet "__rec_scratch"),+          (Syntax.InstructionLocalGet "__rec_ptr"),+          (Syntax.InstructionLocalGet "__rec_scratch"),+          (Syntax.InstructionStore (Syntax.MemoryInstruction {+            Syntax.memoryInstructionType = Syntax.ValTypeI32,+            Syntax.memoryInstructionMemArg = Syntax.MemArg {+              Syntax.memArgOffset = 4,+              Syntax.memArgAlign = 2}})),+          (Syntax.InstructionLocalSet "__rec_scratch"),+          (Syntax.InstructionLocalGet "__rec_ptr"),+          (Syntax.InstructionLocalGet "__rec_scratch"),+          (Syntax.InstructionStore (Syntax.MemoryInstruction {+            Syntax.memoryInstructionType = Syntax.ValTypeI32,+            Syntax.memoryInstructionMemArg = Syntax.MemArg {+              Syntax.memArgOffset = 0,+              Syntax.memArgAlign = 2}})),+          (Syntax.InstructionLocalGet "__rec_ptr")]])))+      Core.TermProject _ -> Right [+        Syntax.InstructionConst (Syntax.ConstValueI32 0)]+      Core.TermRecord v0 ->+        let recFields = Core.recordFields v0+            numFields = Lists.length recFields+            recSize = Math.mul numFields 4+        in (Eithers.bind (Eithers.mapList (\fld -> encodeTerm cx g stringOffsets fieldOffsets variantIndexes funcSigs (Core.fieldTerm fld)) recFields) (\encodedFields ->+          let allFieldInstrs = Lists.concat encodedFields+              allocInstrs =+                      [+                        Syntax.InstructionConst (Syntax.ConstValueI32 recSize),+                        (Syntax.InstructionCall "__alloc"),+                        (Syntax.InstructionLocalSet "__rec_ptr")]+              storeInstrs =+                      Lists.concat (Lists.map (\i -> [+                        Syntax.InstructionLocalSet "__rec_scratch",+                        (Syntax.InstructionLocalGet "__rec_ptr"),+                        (Syntax.InstructionLocalGet "__rec_scratch"),+                        (Syntax.InstructionStore (Syntax.MemoryInstruction {+                          Syntax.memoryInstructionType = Syntax.ValTypeI32,+                          Syntax.memoryInstructionMemArg = Syntax.MemArg {+                            Syntax.memArgOffset = (Math.mul i 4),+                            Syntax.memArgAlign = 2}}))]) (Lists.foldl (\acc -> \_f -> Lists.cons (Lists.length acc) acc) [] recFields))+              finalInstrs = [+                    Syntax.InstructionLocalGet "__rec_ptr"]+          in (Right (Lists.concat [+            allFieldInstrs,+            allocInstrs,+            storeInstrs,+            finalInstrs]))))+      Core.TermSet v0 ->+        let setElems = Sets.toList v0+            numSetElems = Lists.length setElems+            setSize = Math.mul (Math.add numSetElems 1) 4+        in (Eithers.bind (Eithers.mapList (\el -> encodeTerm cx g stringOffsets fieldOffsets variantIndexes funcSigs el) setElems) (\encodedSetElems ->+          let allSetElemInstrs = Lists.concat encodedSetElems+              setAllocInstrs =+                      [+                        Syntax.InstructionConst (Syntax.ConstValueI32 setSize),+                        (Syntax.InstructionCall "__alloc"),+                        (Syntax.InstructionLocalSet "__rec_ptr")]+              setLengthStoreInstrs =+                      [+                        Syntax.InstructionLocalGet "__rec_ptr",+                        (Syntax.InstructionConst (Syntax.ConstValueI32 numSetElems)),+                        (Syntax.InstructionStore (Syntax.MemoryInstruction {+                          Syntax.memoryInstructionType = Syntax.ValTypeI32,+                          Syntax.memoryInstructionMemArg = Syntax.MemArg {+                            Syntax.memArgOffset = 0,+                            Syntax.memArgAlign = 2}}))]+              setStoreInstrs =+                      Lists.concat (Lists.map (\i -> [+                        Syntax.InstructionLocalSet "__rec_scratch",+                        (Syntax.InstructionLocalGet "__rec_ptr"),+                        (Syntax.InstructionLocalGet "__rec_scratch"),+                        (Syntax.InstructionStore (Syntax.MemoryInstruction {+                          Syntax.memoryInstructionType = Syntax.ValTypeI32,+                          Syntax.memoryInstructionMemArg = Syntax.MemArg {+                            Syntax.memArgOffset = (Math.mul (Math.add i 1) 4),+                            Syntax.memArgAlign = 2}}))]) (Lists.foldl (\acc -> \_e -> Lists.cons (Lists.length acc) acc) [] setElems))+              setFinalInstrs = [+                    Syntax.InstructionLocalGet "__rec_ptr"]+          in (Right (Lists.concat [+            allSetElemInstrs,+            setAllocInstrs,+            setLengthStoreInstrs,+            setStoreInstrs,+            setFinalInstrs]))))+      Core.TermTypeApplication v0 -> encodeTerm cx g stringOffsets fieldOffsets variantIndexes funcSigs (Core.typeApplicationTermBody v0)+      Core.TermTypeLambda v0 -> encodeTerm cx g stringOffsets fieldOffsets variantIndexes funcSigs (Core.typeLambdaBody v0)+      Core.TermUnit -> Right [+        Syntax.InstructionConst (Syntax.ConstValueI32 0)]+      Core.TermUnwrap _ -> Right [+        Syntax.InstructionConst (Syntax.ConstValueI32 0)]+      Core.TermVariable v0 ->+        let rawName = Core.unName v0+            lname = Formatting.convertCaseCamelToLowerSnake rawName+        in (Logic.ifElse (Lists.null (Optionals.fromOptional [] (Lists.maybeTail (Strings.splitOn "." rawName)))) (Right [+          Syntax.InstructionLocalGet lname]) (Right [+          Syntax.InstructionConst (Syntax.ConstValueI32 0)]))+      Core.TermWrap v0 -> encodeTerm cx g stringOffsets fieldOffsets variantIndexes funcSigs (Core.wrappedTermBody v0)+      _ -> Left (Errors.ErrorOther (Errors.OtherError "unexpected term variant in WASM encoding"))+encodeTermDefinition :: t0 -> t1 -> M.Map String Int -> M.Map Core.Name [(Core.Name, Int)] -> M.Map Core.Name [(Core.Name, Int)] -> M.Map String ([t2], t3) -> Packaging.TermDefinition -> Either Errors.Error Syntax.ModuleField+encodeTermDefinition cx g stringOffsets fieldOffsets variantIndexes funcSigs tdef =++      let name = Packaging.termDefinitionName tdef+          term = Packaging.termDefinitionBody tdef+          lname = Formatting.convertCaseCamelToLowerSnake (Core.unName name)+          typ =+                  Optionals.cases (Optionals.map Scoping.termSignatureToTypeScheme (Packaging.termDefinitionSignature tdef)) Core.TypeUnit Core.typeSchemeBody+          extracted = extractLambdaParams term+          paramNames = Pairs.first extracted+          innerBody = Pairs.second extracted+          lambdaParamNameStrs = Lists.map (\pn -> Formatting.convertCaseCamelToLowerSnake (Core.unName pn)) paramNames+      in (Eithers.bind (extractParamTypes cx g typ) (\typeParams ->+        let typeParamCount = Lists.length typeParams+            lambdaParamCount = Lists.length lambdaParamNameStrs+            syntheticCount = Logic.ifElse (Equality.gt typeParamCount lambdaParamCount) (Math.sub typeParamCount lambdaParamCount) 0+            syntheticParamNames =+                    Logic.ifElse (Equality.gt syntheticCount 0) (Lists.map (\i -> Strings.cat2 "arg_synth_" (Literals.showInt32 i)) (Math.range 0 (Math.sub syntheticCount 1))) []+            paramNameStrs = Lists.concat2 lambdaParamNameStrs syntheticParamNames+            wasmParams =+                    Lists.map (\pn -> Syntax.Param {+                      Syntax.paramName = (Just pn),+                      Syntax.paramType = Syntax.ValTypeI32}) paramNameStrs+            initPrologue =+                    Lists.concat (Lists.map (\sn -> [+                      Syntax.InstructionLocalGet sn,+                      Syntax.InstructionDrop]) syntheticParamNames)+            resultTypes = [+                  Syntax.ValTypeI32]+            dBody = Strip.deannotateTerm innerBody+            scrutineeInstrs = Optionals.cases (Lists.maybeHead paramNameStrs) [] (\p0 -> [+                  Syntax.InstructionLocalGet p0])+        in (Eithers.bind (case dBody of+          Core.TermProject v0 -> encodeProjection cx g fieldOffsets v0 scrutineeInstrs+          Core.TermCases v0 -> encodeCases cx g stringOffsets fieldOffsets variantIndexes funcSigs v0 scrutineeInstrs+          Core.TermUnwrap _ -> Right [+            Syntax.InstructionConst (Syntax.ConstValueI32 0)]+          _ -> encodeTerm cx g stringOffsets fieldOffsets variantIndexes funcSigs innerBody) (\rawBodyInstrs ->+          let bodyInstrs = Lists.concat2 initPrologue rawBodyInstrs+              referencedLocals = collectInstructionLocals bodyInstrs+              allLocalNames = Sets.toList (Sets.difference referencedLocals (Sets.fromList paramNameStrs))+              wasmLocals =+                      Lists.map (\ln -> Syntax.FuncLocal {+                        Syntax.funcLocalName = (Just ln),+                        Syntax.funcLocalType = Syntax.ValTypeI32}) allLocalNames+          in (Right (Syntax.ModuleFieldFunc (Syntax.Func {+            Syntax.funcName = (Just lname),+            Syntax.funcTypeUse = Syntax.TypeUse {+              Syntax.typeUseIndex = Nothing,+              Syntax.typeUseParams = wasmParams,+              Syntax.typeUseResults = resultTypes},+            Syntax.funcLocals = wasmLocals,+            Syntax.funcBody = bodyInstrs})))))))+encodeType :: t0 -> t1 -> Core.Type -> Either t2 [Syntax.ValType]+encodeType cx g t =++      let typ = Strip.deannotateType t+      in case typ of+        Core.TypeAnnotated v0 -> encodeType cx g (Core.annotatedTypeBody v0)+        Core.TypeFunction v0 -> encodeType cx g (Core.functionTypeCodomain v0)+        Core.TypeUnit -> Right []+        Core.TypeVoid -> Right []+        Core.TypeLiteral v0 -> Right [+          encodeLiteralType v0]+        Core.TypeForall v0 -> encodeType cx g (Core.forallTypeBody v0)+        _ -> Right [+          Syntax.ValTypeI32]+encodeTypeDefinition :: t0 -> t1 -> Packaging.TypeDefinition -> Either t2 [Syntax.ModuleField]+encodeTypeDefinition cx g tdef =++      let name = Packaging.typeDefinitionName tdef+          lname = Formatting.convertCaseCamelToLowerSnake (Names.localNameOf name)+          typ = Core.typeSchemeBody (Packaging.typeDefinitionBody tdef)+          dtyp = Strip.deannotateType typ+      in case dtyp of+        Core.TypeFunction _ -> Eithers.bind (extractParamTypes cx g typ) (\paramTypes -> Eithers.bind (encodeType cx g typ) (\resultTypes -> Right [+          Syntax.ModuleFieldType (Syntax.TypeDef {+            Syntax.typeDefName = (Just lname),+            Syntax.typeDefType = Syntax.FuncType {+              Syntax.funcTypeParams = paramTypes,+              Syntax.funcTypeResults = resultTypes}})]))+        _ -> Right []+encodeValType :: t0 -> t1 -> Core.Type -> Either t2 Syntax.ValType+encodeValType cx g t =++      let typ = Strip.deannotateType t+      in case typ of+        Core.TypeAnnotated v0 -> encodeValType cx g (Core.annotatedTypeBody v0)+        Core.TypeApplication v0 -> encodeValType cx g (Core.applicationTypeFunction v0)+        Core.TypeLiteral v0 -> Right (encodeLiteralType v0)+        Core.TypeUnit -> Right Syntax.ValTypeI32+        Core.TypeVoid -> Right Syntax.ValTypeI32+        Core.TypeForall v0 -> encodeValType cx g (Core.forallTypeBody v0)+        _ -> Right Syntax.ValTypeI32+extractLambdaParams :: Core.Term -> ([Core.Name], Core.Term)+extractLambdaParams term =++      let stripped = Strip.deannotateTerm term+      in case stripped of+        Core.TermLambda v0 ->+          let paramName = Core.lambdaParameter v0+              body = Core.lambdaBody v0+              inner = extractLambdaParams body+          in (Lists.cons paramName (Pairs.first inner), (Pairs.second inner))+        Core.TermCases _ -> ([+          Core.Name "arg_0"], term)+        Core.TermProject _ -> ([+          Core.Name "arg_0"], term)+        Core.TermUnwrap _ -> ([+          Core.Name "arg_0"], term)+        Core.TermTypeLambda v0 -> extractLambdaParams (Core.typeLambdaBody v0)+        Core.TermTypeApplication v0 -> extractLambdaParams (Core.typeApplicationTermBody v0)+        _ -> ([], term)+extractParamTypes :: t0 -> t1 -> Core.Type -> Either t2 [Syntax.ValType]+extractParamTypes cx g t =++      let typ = Strip.deannotateType t+      in case typ of+        Core.TypeFunction v0 -> Eithers.bind (encodeValType cx g (Core.functionTypeDomain v0)) (\domType -> Eithers.bind (extractParamTypes cx g (Core.functionTypeCodomain v0)) (\rest -> Right (Lists.cons domType rest)))+        Core.TypeForall v0 -> extractParamTypes cx g (Core.forallTypeBody v0)+        _ -> Right []+extractSignature :: t0 -> t1 -> Core.Type -> Either t2 ([Syntax.ValType], [Syntax.ValType])+extractSignature cx g t =+    Eithers.bind (extractParamTypes cx g t) (\params -> Eithers.bind (encodeType cx g t) (\results -> Right (clampValTypesToI32 params, (clampValTypesToI32 results))))+hexEscapeString :: Int -> String+hexEscapeString b =++      let byte = Optionals.fromOptional 0 (Math.maybeMod b 256)+          digitToHex =+                  \d -> Logic.ifElse (Equality.lt d 10) (Strings.fromList [+                    Math.add d 48]) (Strings.fromList [+                    Math.add d 87])+      in (Strings.cat [+        "\\",+        (digitToHex (Optionals.fromOptional 0 (Math.maybeDiv byte 16))),+        (digitToHex (Optionals.fromOptional 0 (Math.maybeMod byte 16)))])+moduleToWasm :: Packaging.Module -> [Packaging.Definition] -> t0 -> Graph.Graph -> Either Errors.Error (M.Map String String)+moduleToWasm mod defs cx g =++      let partitioned = Environment.partitionDefinitions defs+          typeDefs = Pairs.first partitioned+          termDefs = Pairs.second partitioned+          stringList = collectStrings termDefs+          stringOffsetsAndEnd = buildStringOffsets stringList+          stringOffsets = Pairs.first stringOffsetsAndEnd+          stringEnd = Pairs.second stringOffsetsAndEnd+          dataField = stringDataSegment stringOffsets+          fieldOffsets = buildFieldOffsets g+          variantIndexes = buildVariantIndexes g+          funcSigs = buildFunctionSignatures cx g termDefs+      in (Eithers.bind (Eithers.mapList (encodeTypeDefinition cx g) typeDefs) (\typeFields -> Eithers.bind (Eithers.mapList (encodeTermDefinition cx g stringOffsets fieldOffsets variantIndexes funcSigs) termDefs) (\termFields ->+        let allFields = Lists.concat2 (Lists.concat typeFields) termFields+            bumpGlobal =+                    Syntax.ModuleFieldGlobal (Syntax.GlobalDef {+                      Syntax.globalDefName = (Just "__bump_ptr"),+                      Syntax.globalDefType = Syntax.GlobalType {+                        Syntax.globalTypeValType = Syntax.ValTypeI32,+                        Syntax.globalTypeMutable = True},+                      Syntax.globalDefInit = [+                        Syntax.InstructionConst (Syntax.ConstValueI32 stringEnd)]})+            allocFunc =+                    Syntax.ModuleFieldFunc (Syntax.Func {+                      Syntax.funcName = (Just "__alloc"),+                      Syntax.funcTypeUse = Syntax.TypeUse {+                        Syntax.typeUseIndex = Nothing,+                        Syntax.typeUseParams = [+                          Syntax.Param {+                            Syntax.paramName = (Just "sz"),+                            Syntax.paramType = Syntax.ValTypeI32}],+                        Syntax.typeUseResults = [+                          Syntax.ValTypeI32]},+                      Syntax.funcLocals = [],+                      Syntax.funcBody = [+                        Syntax.InstructionGlobalGet "__bump_ptr",+                        (Syntax.InstructionGlobalGet "__bump_ptr"),+                        (Syntax.InstructionLocalGet "sz"),+                        (Syntax.InstructionBinop (Syntax.NumericOp {+                          Syntax.numericOpType = Syntax.ValTypeI32,+                          Syntax.numericOpName = "add"})),+                        (Syntax.InstructionGlobalSet "__bump_ptr")]})+            memField =+                    Syntax.ModuleFieldMemory (Syntax.MemoryDef {+                      Syntax.memoryDefName = (Just "memory"),+                      Syntax.memoryDefLimits = Syntax.Limits {+                        Syntax.limitsMin = 2,+                        Syntax.limitsMax = Nothing}})+            memExport =+                    Syntax.ModuleFieldExport (Syntax.ExportDef {+                      Syntax.exportDefName = "memory",+                      Syntax.exportDefDesc = (Syntax.ExportDescMemory "memory")})+            bumpExport =+                    Syntax.ModuleFieldExport (Syntax.ExportDef {+                      Syntax.exportDefName = "__bump_ptr",+                      Syntax.exportDefDesc = (Syntax.ExportDescGlobal "__bump_ptr")})+            allocExport =+                    Syntax.ModuleFieldExport (Syntax.ExportDef {+                      Syntax.exportDefName = "__alloc",+                      Syntax.exportDefDesc = (Syntax.ExportDescFunc "__alloc")})+            closureType =+                    Syntax.ModuleFieldType (Syntax.TypeDef {+                      Syntax.typeDefName = (Just "__closure_1"),+                      Syntax.typeDefType = Syntax.FuncType {+                        Syntax.funcTypeParams = [+                          Syntax.ValTypeI32,+                          Syntax.ValTypeI32],+                        Syntax.funcTypeResults = [+                          Syntax.ValTypeI32]}})+            closureTable =+                    Syntax.ModuleFieldTable (Syntax.TableDef {+                      Syntax.tableDefName = (Just "__closure_table"),+                      Syntax.tableDefRefType = Syntax.RefTypeFuncref,+                      Syntax.tableDefLimits = Syntax.Limits {+                        Syntax.limitsMin = 0,+                        Syntax.limitsMax = Nothing}})+            funcExports =+                    Lists.map (\td ->+                      let ename = Formatting.convertCaseCamelToLowerSnake (Core.unName (Packaging.termDefinitionName td))+                      in (Syntax.ModuleFieldExport (Syntax.ExportDef {+                        Syntax.exportDefName = ename,+                        Syntax.exportDefDesc = (Syntax.ExportDescFunc ename)}))) termDefs+            allBodyInstrs =+                    Lists.concat (Lists.map (\tf -> case tf of+                      Syntax.ModuleFieldFunc v0 -> Syntax.funcBody v0+                      _ -> []) termFields)+            allCallTargets = collectCallTargets allBodyInstrs+            localFuncNames =+                    Sets.insert "__alloc" (Sets.fromList (Lists.map (\td -> Formatting.convertCaseCamelToLowerSnake (Core.unName (Packaging.termDefinitionName td))) termDefs))+            externalCalls = Sets.toList (Sets.difference allCallTargets localFuncNames)+            defaultSig = ([+                  Syntax.ValTypeI32], [+                  Syntax.ValTypeI32])+            importFields =+                    Lists.map (\fname ->+                      let parts = Strings.splitOn "." fname+                          modName = Strings.intercalate "." (Lists.reverse (Optionals.fromOptional [] (Lists.maybeTail (Lists.reverse parts))))+                          sig = Optionals.fromOptional defaultSig (Maps.lookup fname funcSigs)+                          sigParams = Pairs.first sig+                          sigResults = Pairs.second sig+                          wasmImportParams =+                                  Lists.map (\vt -> Syntax.Param {+                                    Syntax.paramName = Nothing,+                                    Syntax.paramType = vt}) sigParams+                      in (Syntax.ModuleFieldImport (Syntax.ImportDef {+                        Syntax.importDefModule = modName,+                        Syntax.importDefName = fname,+                        Syntax.importDefDesc = (Syntax.ImportDescFunc (Syntax.ImportFunc {+                          Syntax.importFuncName = (Just fname),+                          Syntax.importFuncTypeUse = Syntax.TypeUse {+                            Syntax.typeUseIndex = Nothing,+                            Syntax.typeUseParams = wasmImportParams,+                            Syntax.typeUseResults = sigResults}}))}))) externalCalls+            wasmMod =+                    Syntax.Module {+                      Syntax.moduleName = Nothing,+                      Syntax.moduleFields = (Lists.concat [+                        importFields,+                        [+                          closureType,+                          memField,+                          memExport,+                          dataField,+                          bumpGlobal,+                          bumpExport,+                          allocFunc,+                          allocExport,+                          closureTable],+                        funcExports,+                        allFields])}+            code = Serialization.printExpr (Serialization.parenthesize (Serde.moduleToExpr wasmMod))+            filePath = Names.moduleNameToFilePath Util.CaseConventionLowerSnake (File.FileExtension "wat") (Packaging.moduleName mod)+        in (Right (Maps.singleton filePath code)))))+peelLambdaApp :: Core.Term -> [t0] -> ([Core.Name], Core.Term)+peelLambdaApp term args =+    Logic.ifElse (Lists.null args) ([], term) (+      let stripped = Strip.deannotateTerm term+      in case stripped of+        Core.TermLambda v0 ->+          let paramName = Core.lambdaParameter v0+              body = Core.lambdaBody v0+              restArgs = Optionals.fromOptional [] (Lists.maybeTail args)+              inner = peelLambdaApp body restArgs+          in (Lists.cons paramName (Pairs.first inner), (Pairs.second inner))+        _ -> ([], term))+stringDataSegment :: Ord t0 => (M.Map String t0 -> Syntax.ModuleField)+stringDataSegment offsets =++      let entries = Lists.sortOn Pairs.second (Maps.toList offsets)+          bytesForEntry =+                  \entry ->+                    let s = Pairs.first entry+                        len = Strings.length s+                        lenBytes =+                                [+                                  Optionals.fromOptional 0 (Math.maybeMod len 256),+                                  (Optionals.fromOptional 0 (Math.maybeMod (Optionals.fromOptional 0 (Math.maybeDiv len 256)) 256)),+                                  (Optionals.fromOptional 0 (Math.maybeMod (Optionals.fromOptional 0 (Math.maybeDiv len 65536)) 256)),+                                  (Optionals.fromOptional 0 (Math.maybeMod (Optionals.fromOptional 0 (Math.maybeDiv len 16777216)) 256))]+                        contentBytes = Strings.toList s+                        allBytes = Lists.concat2 lenBytes contentBytes+                    in (Strings.cat (Lists.map (\b -> hexEscapeString b) allBytes))+          allHex = Strings.cat (Lists.map bytesForEntry entries)+      in (Syntax.ModuleFieldData (Syntax.DataSegment {+        Syntax.dataSegmentName = Nothing,+        Syntax.dataSegmentMode = (Syntax.DataModeActive [+          Syntax.InstructionConst (Syntax.ConstValueI32 1024)]),+        Syntax.dataSegmentBytes = allHex}))

@@ -0,0 +1,173 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Language constraints and reserved words for WebAssembly (WAT text format)++module Hydra.Wasm.Language where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Lexical as Lexical+import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists+import qualified Hydra.Overlay.Haskell.Lib.Sets as Sets+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Set as S+-- | Language constraints for WebAssembly+wasmLanguage :: Coders.Language+wasmLanguage =+    Coders.Language {+      Coders.languageName = (Coders.LanguageName "hydra.wasm"),+      Coders.languageConstraints = Coders.LanguageConstraints {+        Coders.languageConstraintsLiteralVariants = literalVariants,+        Coders.languageConstraintsFloatTypes = floatTypes,+        Coders.languageConstraintsIntegerTypes = integerTypes,+        Coders.languageConstraintsTermVariants = termVariants,+        Coders.languageConstraintsTypeVariants = typeVariants,+        Coders.languageConstraintsTypes = typePredicate}}+  where+    literalVariants =+        Sets.fromList [+          Variants.LiteralVariantBoolean,+          Variants.LiteralVariantFloat,+          Variants.LiteralVariantInteger,+          Variants.LiteralVariantString]+    floatTypes =+        Sets.fromList [+          Core.FloatTypeFloat32,+          Core.FloatTypeFloat64]+    integerTypes =+        Sets.fromList [+          Core.IntegerTypeInt8,+          Core.IntegerTypeInt16,+          Core.IntegerTypeInt32,+          Core.IntegerTypeInt64,+          Core.IntegerTypeUint8,+          Core.IntegerTypeUint16,+          Core.IntegerTypeUint32,+          Core.IntegerTypeUint64]+    termVariants =+        Sets.fromList [+          Variants.TermVariantAnnotated,+          Variants.TermVariantApplication,+          Variants.TermVariantCases,+          Variants.TermVariantEither,+          Variants.TermVariantInject,+          Variants.TermVariantLambda,+          Variants.TermVariantLet,+          Variants.TermVariantList,+          Variants.TermVariantLiteral,+          Variants.TermVariantMap,+          Variants.TermVariantOptional,+          Variants.TermVariantPair,+          Variants.TermVariantProject,+          Variants.TermVariantRecord,+          Variants.TermVariantSet,+          Variants.TermVariantTypeApplication,+          Variants.TermVariantTypeLambda,+          Variants.TermVariantUnit,+          Variants.TermVariantUnwrap,+          Variants.TermVariantVariable,+          Variants.TermVariantWrap]+    typeVariants =+        Sets.fromList [+          Variants.TypeVariantAnnotated,+          Variants.TypeVariantApplication,+          Variants.TypeVariantEither,+          Variants.TypeVariantFunction,+          Variants.TypeVariantForall,+          Variants.TypeVariantList,+          Variants.TypeVariantLiteral,+          Variants.TypeVariantMap,+          Variants.TypeVariantOptional,+          Variants.TypeVariantPair,+          Variants.TypeVariantRecord,+          Variants.TypeVariantSet,+          Variants.TypeVariantUnion,+          Variants.TypeVariantUnit,+          Variants.TypeVariantVariable,+          Variants.TypeVariantVoid,+          Variants.TypeVariantWrap]+    typePredicate = \_ -> True+-- | A set of reserved words in WebAssembly text format+wasmReservedWords :: S.Set String+wasmReservedWords =+    Sets.fromList (Lists.concat [+      keywords,+      valueTypes,+      instructionPrefixes])+  where+    keywords =+        [+          "module",+          "type",+          "func",+          "param",+          "result",+          "local",+          "global",+          "table",+          "memory",+          "elem",+          "data",+          "start",+          "import",+          "export",+          "block",+          "loop",+          "if",+          "then",+          "else",+          "end",+          "br",+          "br_if",+          "br_table",+          "return",+          "call",+          "call_indirect",+          "drop",+          "select",+          "unreachable",+          "nop",+          "mut",+          "offset",+          "align"]+    valueTypes =+        [+          "i32",+          "i64",+          "f32",+          "f64",+          "v128",+          "funcref",+          "externref"]+    instructionPrefixes =+        [+          "i32",+          "i64",+          "f32",+          "f64",+          "local.get",+          "local.set",+          "local.tee",+          "global.get",+          "global.set",+          "memory.size",+          "memory.grow"]

@@ -0,0 +1,551 @@+-- Note: this is an automatically generated file. Do not edit.+-- | WebAssembly serializer: converts WAT AST to concrete WAT text format++module Hydra.Wasm.Serde where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Constants as Constants+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Overlay.Haskell.Lib.Equality as Equality+import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists+import qualified Hydra.Overlay.Haskell.Lib.Literals as Literals+import qualified Hydra.Overlay.Haskell.Lib.Logic as Logic+import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals+import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Serialization as Serialization+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import qualified Hydra.Wasm.Syntax as Syntax+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | Serialize a block or loop instruction to WAT+blockInstructionToExpr :: String -> Syntax.BlockInstruction -> Ast.Expr+blockInstructionToExpr keyword b =++      let label = Syntax.blockInstructionLabel b+          bt = Syntax.blockInstructionBlockType b+          body = Syntax.blockInstructionBody b+          labelStr = Optionals.cases label "" (\l -> Strings.cat2 " $" l)+          btPart = blockTypeToExpr bt+          bodyParts = Lists.map instructionToExpr body+          header =+                  Serialization.spaceSep (Optionals.cat [+                    Just (Serialization.cst (Strings.cat [+                      "(",+                      keyword,+                      labelStr])),+                    btPart])+      in (Serialization.newlineSep (Lists.concat [+        [+          header],+        (Lists.map (\p -> Serialization.cst (Strings.cat2 "  " (Serialization.printExpr p))) bodyParts),+        [+          Serialization.cst ")"]]))+-- | Serialize a block type to WAT+blockTypeToExpr :: Syntax.BlockType -> Maybe Ast.Expr+blockTypeToExpr bt =+    case bt of+      Syntax.BlockTypeEmpty -> Nothing+      Syntax.BlockTypeValue v0 -> Just (Serialization.cst (Strings.cat [+        "(result ",+        (valTypeToStr v0),+        ")"]))+      Syntax.BlockTypeTypeUse v0 -> Just (typeUseToExpr v0)+-- | Serialize a constant value instruction to WAT+constValueToExpr :: Syntax.ConstValue -> Ast.Expr+constValueToExpr c =+    case c of+      Syntax.ConstValueI32 v0 -> Serialization.cst (Strings.cat2 "i32.const " (Literals.showInt32 v0))+      Syntax.ConstValueI64 v0 -> Serialization.cst (Strings.cat2 "i64.const " (Literals.showInt64 v0))+      Syntax.ConstValueF32 v0 -> Serialization.cst (Strings.cat2 "f32.const " (Literals.showFloat32 v0))+      Syntax.ConstValueF64 v0 -> Serialization.cst (Strings.cat2 "f64.const " (Literals.showFloat64 v0))+-- | Serialize a data segment to WAT+dataSegmentToExpr :: Syntax.DataSegment -> Ast.Expr+dataSegmentToExpr d =++      let name = Syntax.dataSegmentName d+          mode = Syntax.dataSegmentMode d+          bytes = Syntax.dataSegmentBytes d+          nameStr = Optionals.cases name "" (\n -> Strings.cat2 " $" n)+      in case mode of+        Syntax.DataModeActive v0 -> Serialization.spaceSep [+          Serialization.cst (Strings.cat2 "(data" nameStr),+          (Serialization.spaceSep [+            Serialization.cst "(offset",+            (Serialization.spaceSep (Lists.map instructionToExpr v0)),+            (Serialization.cst ")")]),+          (Serialization.cst (Strings.cat [+            "\"",+            bytes,+            "\")"]))]+        Syntax.DataModePassive -> Serialization.spaceSep [+          Serialization.cst (Strings.cat2 "(data" nameStr),+          (Serialization.cst (Strings.cat [+            "\"",+            bytes,+            "\")"]))]+-- | Serialize an export declaration to WAT+exportDefToExpr :: Syntax.ExportDef -> Ast.Expr+exportDefToExpr e =++      let name = Syntax.exportDefName e+          desc = Syntax.exportDefDesc e+      in (Serialization.spaceSep [+        Serialization.cst "(export",+        (Serialization.cst (Strings.cat [+          "\"",+          name,+          "\""])),+        (exportDescToExpr desc),+        (Serialization.cst ")")])+-- | Serialize an export descriptor to WAT+exportDescToExpr :: Syntax.ExportDesc -> Ast.Expr+exportDescToExpr desc =+    case desc of+      Syntax.ExportDescFunc v0 -> Serialization.cst (Strings.cat [+        "(func $",+        v0,+        ")"])+      Syntax.ExportDescMemory v0 -> Serialization.cst (Strings.cat [+        "(memory $",+        v0,+        ")"])+      Syntax.ExportDescTable v0 -> Serialization.cst (Strings.cat [+        "(table $",+        v0,+        ")"])+      Syntax.ExportDescGlobal v0 -> Serialization.cst (Strings.cat [+        "(global $",+        v0,+        ")"])+-- | Serialize a local variable declaration to WAT+funcLocalToExpr :: Syntax.FuncLocal -> Ast.Expr+funcLocalToExpr l =++      let name = Syntax.funcLocalName l+          typ = Syntax.funcLocalType l+          nameStr = Optionals.cases name "" (\n -> Strings.cat2 " $" n)+      in (Serialization.cst (Strings.cat [+        "(local",+        nameStr,+        " ",+        (valTypeToStr typ),+        ")"]))+-- | Serialize a function definition to WAT+funcToExpr :: Syntax.Func -> Ast.Expr+funcToExpr f =++      let name = Syntax.funcName f+          typeUse = Syntax.funcTypeUse f+          locals = Syntax.funcLocals f+          body = Syntax.funcBody f+          nameStr = Optionals.cases name "" (\n -> Strings.cat2 " $" n)+          headerStr = Strings.cat2 "(func" nameStr+          typeUsePart = typeUseToExpr typeUse+          localParts = Lists.map funcLocalToExpr locals+          bodyParts = Lists.map instructionToExpr body+          innerParts = Lists.concat2 localParts bodyParts+      in (Logic.ifElse (Lists.null innerParts) (Serialization.spaceSep [+        Serialization.cst headerStr,+        typeUsePart,+        (Serialization.cst ")")]) (Serialization.newlineSep (Lists.concat [+        [+          Serialization.spaceSep [+            Serialization.cst headerStr,+            typeUsePart]],+        (Lists.map (\p -> Serialization.cst (Strings.cat2 "  " (Serialization.printExpr p))) innerParts),+        [+          Serialization.cst ")"]])))+-- | Serialize a function type to WAT+funcTypeToExpr :: Syntax.FuncType -> Ast.Expr+funcTypeToExpr ft =++      let params = Syntax.funcTypeParams ft+          results = Syntax.funcTypeResults ft+          paramParts =+                  Lists.map (\p -> Serialization.cst (Strings.cat [+                    "(param ",+                    (valTypeToStr p),+                    ")"])) params+          resultParts =+                  Lists.map (\r -> Serialization.cst (Strings.cat [+                    "(result ",+                    (valTypeToStr r),+                    ")"])) results+      in (Serialization.spaceSep (Optionals.cat [+        Just (Serialization.cst "(func"),+        (Logic.ifElse (Lists.null paramParts) Nothing (Just (Serialization.spaceSep paramParts))),+        (Logic.ifElse (Lists.null resultParts) Nothing (Just (Serialization.spaceSep resultParts))),+        (Just (Serialization.cst ")"))]))+-- | Serialize a global definition to WAT+globalDefToExpr :: Syntax.GlobalDef -> Ast.Expr+globalDefToExpr g =++      let name = Syntax.globalDefName g+          gt = Syntax.globalDefType g+          init = Syntax.globalDefInit g+          nameStr = Optionals.cases name "" (\n -> Strings.cat2 " $" n)+      in (Serialization.spaceSep [+        Serialization.cst (Strings.cat2 "(global" nameStr),+        (globalTypeToExpr gt),+        (Serialization.spaceSep (Lists.map instructionToExpr init)),+        (Serialization.cst ")")])+-- | Serialize a global type to WAT+globalTypeToExpr :: Syntax.GlobalType -> Ast.Expr+globalTypeToExpr gt =++      let vt = Syntax.globalTypeValType gt+          mut = Syntax.globalTypeMutable gt+      in (Logic.ifElse mut (Serialization.cst (Strings.cat [+        "(mut ",+        (valTypeToStr vt),+        ")"])) (Serialization.cst (valTypeToStr vt)))+-- | Serialize an if instruction to WAT+ifInstructionToExpr :: Syntax.IfInstruction -> Ast.Expr+ifInstructionToExpr i =++      let label = Syntax.ifInstructionLabel i+          bt = Syntax.ifInstructionBlockType i+          thenBranch = Syntax.ifInstructionThen i+          elseBranch = Syntax.ifInstructionElse i+          labelStr = Optionals.cases label "" (\l -> Strings.cat2 " $" l)+          btPart = blockTypeToExpr bt+          thenParts = Lists.map instructionToExpr thenBranch+          elseParts = Lists.map instructionToExpr elseBranch+          header =+                  Serialization.spaceSep (Optionals.cat [+                    Just (Serialization.cst (Strings.cat [+                      "(if",+                      labelStr])),+                    btPart])+          thenBlock =+                  Serialization.newlineSep (Lists.concat [+                    [+                      Serialization.cst "(then"],+                    (Lists.map (\p -> Serialization.cst (Strings.cat2 "  " (Serialization.printExpr p))) thenParts),+                    [+                      Serialization.cst ")"]])+          elseBlock =+                  Serialization.newlineSep (Lists.concat [+                    [+                      Serialization.cst "(else"],+                    (Lists.map (\p -> Serialization.cst (Strings.cat2 "  " (Serialization.printExpr p))) elseParts),+                    [+                      Serialization.cst ")"]])+      in (Logic.ifElse (Lists.null elseParts) (Serialization.newlineSep [+        header,+        thenBlock,+        (Serialization.cst ")")]) (Serialization.newlineSep [+        header,+        thenBlock,+        elseBlock,+        (Serialization.cst ")")]))+-- | Serialize an import declaration to WAT+importDefToExpr :: Syntax.ImportDef -> Ast.Expr+importDefToExpr i =++      let modName = Syntax.importDefModule i+          name = Syntax.importDefName i+          desc = Syntax.importDefDesc i+      in (Serialization.spaceSep [+        Serialization.cst "(import",+        (Serialization.cst (Strings.cat [+          "\"",+          modName,+          "\""])),+        (Serialization.cst (Strings.cat [+          "\"",+          name,+          "\""])),+        (importDescToExpr desc),+        (Serialization.cst ")")])+-- | Serialize an import descriptor to WAT+importDescToExpr :: Syntax.ImportDesc -> Ast.Expr+importDescToExpr desc =+    case desc of+      Syntax.ImportDescFunc v0 ->+        let name = Syntax.importFuncName v0+            tu = Syntax.importFuncTypeUse v0+            nameStr = Optionals.cases name "" (\n -> Strings.cat2 " $" n)+        in (Serialization.spaceSep [+          Serialization.cst (Strings.cat2 "(func" nameStr),+          (typeUseToExpr tu),+          (Serialization.cst ")")])+      Syntax.ImportDescMemory v0 ->+        let name = Syntax.importMemoryName v0+            lim = Syntax.importMemoryLimits v0+            nameStr = Optionals.cases name "" (\n -> Strings.cat2 " $" n)+        in (Serialization.spaceSep [+          Serialization.cst (Strings.cat2 "(memory" nameStr),+          (limitsToExpr lim),+          (Serialization.cst ")")])+      Syntax.ImportDescTable v0 ->+        let name = Syntax.importTableName v0+            rt = Syntax.importTableRefType v0+            lim = Syntax.importTableLimits v0+            nameStr = Optionals.cases name "" (\n -> Strings.cat2 " $" n)+        in (Serialization.spaceSep [+          Serialization.cst (Strings.cat2 "(table" nameStr),+          (limitsToExpr lim),+          (Serialization.cst (refTypeToStr rt)),+          (Serialization.cst ")")])+      Syntax.ImportDescGlobal v0 ->+        let name = Syntax.importGlobalName v0+            gt = Syntax.importGlobalType v0+            nameStr = Optionals.cases name "" (\n -> Strings.cat2 " $" n)+        in (Serialization.spaceSep [+          Serialization.cst (Strings.cat2 "(global" nameStr),+          (globalTypeToExpr gt),+          (Serialization.cst ")")])+-- | Serialize an instruction to WAT+instructionToExpr :: Syntax.Instruction -> Ast.Expr+instructionToExpr instr =+    case instr of+      Syntax.InstructionConst v0 -> constValueToExpr v0+      Syntax.InstructionLocalGet v0 -> Serialization.cst (Strings.cat [+        "local.get $",+        v0])+      Syntax.InstructionLocalSet v0 -> Serialization.cst (Strings.cat [+        "local.set $",+        v0])+      Syntax.InstructionLocalTee v0 -> Serialization.cst (Strings.cat [+        "local.tee $",+        v0])+      Syntax.InstructionGlobalGet v0 -> Serialization.cst (Strings.cat [+        "global.get $",+        v0])+      Syntax.InstructionGlobalSet v0 -> Serialization.cst (Strings.cat [+        "global.set $",+        v0])+      Syntax.InstructionLoad v0 ->+        let vt = Syntax.memoryInstructionType v0+            ma = Syntax.memoryInstructionMemArg v0+            off = Syntax.memArgOffset ma+            offStr = Logic.ifElse (Equality.equal off 0) "" (Strings.cat2 " offset=" (Literals.showInt32 off))+        in (Serialization.cst (Strings.cat [+          valTypeToStr vt,+          ".load",+          offStr]))+      Syntax.InstructionStore v0 ->+        let vt = Syntax.memoryInstructionType v0+            ma = Syntax.memoryInstructionMemArg v0+            off = Syntax.memArgOffset ma+            offStr = Logic.ifElse (Equality.equal off 0) "" (Strings.cat2 " offset=" (Literals.showInt32 off))+        in (Serialization.cst (Strings.cat [+          valTypeToStr vt,+          ".store",+          offStr]))+      Syntax.InstructionUnop v0 ->+        let vt = Syntax.numericOpType v0+            nm = Syntax.numericOpName v0+        in (Serialization.cst (Strings.cat [+          valTypeToStr vt,+          ".",+          nm]))+      Syntax.InstructionBinop v0 ->+        let vt = Syntax.numericOpType v0+            nm = Syntax.numericOpName v0+        in (Serialization.cst (Strings.cat [+          valTypeToStr vt,+          ".",+          nm]))+      Syntax.InstructionTestop v0 ->+        let vt = Syntax.numericOpType v0+            nm = Syntax.numericOpName v0+        in (Serialization.cst (Strings.cat [+          valTypeToStr vt,+          ".",+          nm]))+      Syntax.InstructionRelop v0 ->+        let vt = Syntax.numericOpType v0+            nm = Syntax.numericOpName v0+        in (Serialization.cst (Strings.cat [+          valTypeToStr vt,+          ".",+          nm]))+      Syntax.InstructionConvert v0 -> Serialization.cst v0+      Syntax.InstructionCall v0 -> Serialization.cst (Strings.cat [+        "call $",+        v0])+      Syntax.InstructionCallIndirect v0 -> Serialization.spaceSep [+        Serialization.cst "call_indirect",+        (typeUseToExpr v0)]+      Syntax.InstructionBlock v0 -> blockInstructionToExpr "block" v0+      Syntax.InstructionLoop v0 -> blockInstructionToExpr "loop" v0+      Syntax.InstructionIf v0 -> ifInstructionToExpr v0+      Syntax.InstructionBr v0 -> Serialization.cst (Strings.cat [+        "br $",+        v0])+      Syntax.InstructionBrIf v0 -> Serialization.cst (Strings.cat [+        "br_if $",+        v0])+      Syntax.InstructionBrTable v0 ->+        let labels = Syntax.brTableArgsLabels v0+            def = Syntax.brTableArgsDefault v0+        in (Serialization.cst (Strings.cat [+          "br_table ",+          (Strings.intercalate " " (Lists.map (\l -> Strings.cat2 "$" l) labels)),+          " $",+          def]))+      Syntax.InstructionReturn -> Serialization.cst "return"+      Syntax.InstructionDrop -> Serialization.cst "drop"+      Syntax.InstructionSelect -> Serialization.cst "select"+      Syntax.InstructionUnreachable -> Serialization.cst "unreachable"+      Syntax.InstructionNop -> Serialization.cst "nop"+      Syntax.InstructionMemorySize -> Serialization.cst "memory.size"+      Syntax.InstructionMemoryGrow -> Serialization.cst "memory.grow"+      Syntax.InstructionRefNull v0 -> Serialization.cst (Strings.cat [+        "ref.null ",+        (refTypeToStr v0)])+      Syntax.InstructionRefIsNull -> Serialization.cst "ref.is_null"+      Syntax.InstructionRaw v0 -> Serialization.cst v0+-- | Serialize limits to WAT+limitsToExpr :: Syntax.Limits -> Ast.Expr+limitsToExpr l =++      let mn = Syntax.limitsMin l+          mx = Syntax.limitsMax l+      in (Serialization.spaceSep (Optionals.cat [+        Just (Serialization.cst (Literals.showInt32 mn)),+        (Optionals.map (\m -> Serialization.cst (Literals.showInt32 m)) mx)]))+-- | Serialize a memory definition to WAT+memoryDefToExpr :: Syntax.MemoryDef -> Ast.Expr+memoryDefToExpr m =++      let name = Syntax.memoryDefName m+          lim = Syntax.memoryDefLimits m+          nameStr = Optionals.cases name "" (\n -> Strings.cat2 " $" n)+      in (Serialization.spaceSep [+        Serialization.cst (Strings.cat2 "(memory" nameStr),+        (limitsToExpr lim),+        (Serialization.cst ")")])+-- | Serialize a module field to a WAT expression+moduleFieldToExpr :: Syntax.ModuleField -> Ast.Expr+moduleFieldToExpr field =+    case field of+      Syntax.ModuleFieldType v0 -> typeDefToExpr v0+      Syntax.ModuleFieldFunc v0 -> funcToExpr v0+      Syntax.ModuleFieldMemory v0 -> memoryDefToExpr v0+      Syntax.ModuleFieldTable v0 -> tableDefToExpr v0+      Syntax.ModuleFieldGlobal v0 -> globalDefToExpr v0+      Syntax.ModuleFieldImport v0 -> importDefToExpr v0+      Syntax.ModuleFieldExport v0 -> exportDefToExpr v0+      Syntax.ModuleFieldData v0 -> dataSegmentToExpr v0+      Syntax.ModuleFieldElem _ -> Serialization.cst ";; elem segment (not yet supported)"+      Syntax.ModuleFieldStart v0 -> Serialization.cst (Strings.cat [+        "(start $",+        v0,+        ")"])+-- | Serialize a WebAssembly module to a WAT expression+moduleToExpr :: Syntax.Module -> Ast.Expr+moduleToExpr mod =++      let name = Syntax.moduleName mod+          fields = Syntax.moduleFields mod+          nameStr = Optionals.cases name "" (\n -> Strings.cat2 " $" n)+          fieldExprs = Lists.map moduleFieldToExpr fields+      in (Serialization.newlineSep (Lists.concat [+        [+          Serialization.cst (Strings.cat2 "(module" nameStr)],+        (Lists.map (\fe -> Serialization.cst (Strings.cat2 "  " (Serialization.printExpr fe))) fieldExprs),+        [+          Serialization.cst ")"]]))+-- | Serialize a function parameter to WAT+paramToExpr :: Syntax.Param -> Ast.Expr+paramToExpr p =++      let name = Syntax.paramName p+          typ = Syntax.paramType p+          nameStr = Optionals.cases name "" (\n -> Strings.cat2 " $" n)+      in (Serialization.cst (Strings.cat [+        "(param",+        nameStr,+        " ",+        (valTypeToStr typ),+        ")"]))+-- | Convert a reference type to its WAT string+refTypeToStr :: Syntax.RefType -> String+refTypeToStr rt =+    case rt of+      Syntax.RefTypeFuncref -> "funcref"+      Syntax.RefTypeExternref -> "externref"+-- | Serialize a table definition to WAT+tableDefToExpr :: Syntax.TableDef -> Ast.Expr+tableDefToExpr t =++      let name = Syntax.tableDefName t+          rt = Syntax.tableDefRefType t+          lim = Syntax.tableDefLimits t+          nameStr = Optionals.cases name "" (\n -> Strings.cat2 " $" n)+      in (Serialization.spaceSep [+        Serialization.cst (Strings.cat2 "(table" nameStr),+        (limitsToExpr lim),+        (Serialization.cst (refTypeToStr rt)),+        (Serialization.cst ")")])+-- | Convert a string to a WAT comment+toWatComment :: String -> String+toWatComment s =+    Strings.cat [+      ";; ",+      s]+-- | Serialize a type definition to WAT+typeDefToExpr :: Syntax.TypeDef -> Ast.Expr+typeDefToExpr td =++      let name = Syntax.typeDefName td+          ft = Syntax.typeDefType td+          nameStr = Optionals.cases name "" (\n -> Strings.cat2 " $" n)+      in (Serialization.spaceSep [+        Serialization.cst (Strings.cat2 "(type" nameStr),+        (funcTypeToExpr ft),+        (Serialization.cst ")")])+-- | Serialize a type use clause to WAT+typeUseToExpr :: Syntax.TypeUse -> Ast.Expr+typeUseToExpr tu =++      let idx = Syntax.typeUseIndex tu+          params = Syntax.typeUseParams tu+          results = Syntax.typeUseResults tu+          idxPart =+                  Optionals.map (\i -> Serialization.cst (Strings.cat [+                    "(type $",+                    i,+                    ")"])) idx+          paramParts = Lists.map paramToExpr params+          resultParts =+                  Lists.map (\r -> Serialization.cst (Strings.cat [+                    "(result ",+                    (valTypeToStr r),+                    ")"])) results+      in (Serialization.spaceSep (Optionals.cat (Lists.concat [+        [+          idxPart],+        (Lists.map (\p -> Just p) paramParts),+        (Lists.map (\r -> Just r) resultParts)])))+-- | Convert a value type to its WAT string representation+valTypeToStr :: Syntax.ValType -> String+valTypeToStr vt =+    case vt of+      Syntax.ValTypeI32 -> "i32"+      Syntax.ValTypeI64 -> "i64"+      Syntax.ValTypeF32 -> "f32"+      Syntax.ValTypeF64 -> "f64"+      Syntax.ValTypeFuncref -> "funcref"+      Syntax.ValTypeExternref -> "externref"

@@ -0,0 +1,601 @@+-- Note: this is an automatically generated file. Do not edit.+-- | A WebAssembly text format (WAT) syntax model, based on the WebAssembly spec (https://webassembly.github.io/spec/core/), retrieved 2026-04-06++module Hydra.Wasm.Syntax where+import qualified Hydra.Core as Core+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Int as I+-- | A WebAssembly module, the top-level container+data Module =+  Module {+    -- | Optional module name+    moduleName :: (Maybe String),+    -- | The module's fields (types, functions, memories, tables, globals, imports, exports, etc.)+    moduleFields :: [ModuleField]}+  deriving (Eq, Ord, Read, Show)+_Module = Core.Name "hydra.wasm.syntax.Module"+_Module_name = Core.Name "name"+_Module_fields = Core.Name "fields"+-- | A field within a WebAssembly module+data ModuleField =+  -- | A type definition+  ModuleFieldType TypeDef |+  -- | A function definition+  ModuleFieldFunc Func |+  -- | A memory definition+  ModuleFieldMemory MemoryDef |+  -- | A table definition+  ModuleFieldTable TableDef |+  -- | A global variable definition+  ModuleFieldGlobal GlobalDef |+  -- | An import declaration+  ModuleFieldImport ImportDef |+  -- | An export declaration+  ModuleFieldExport ExportDef |+  -- | A data segment+  ModuleFieldData DataSegment |+  -- | An element segment+  ModuleFieldElem ElemSegment |+  -- | A start function index+  ModuleFieldStart String+  deriving (Eq, Ord, Read, Show)+_ModuleField = Core.Name "hydra.wasm.syntax.ModuleField"+_ModuleField_type = Core.Name "type"+_ModuleField_func = Core.Name "func"+_ModuleField_memory = Core.Name "memory"+_ModuleField_table = Core.Name "table"+_ModuleField_global = Core.Name "global"+_ModuleField_import = Core.Name "import"+_ModuleField_export = Core.Name "export"+_ModuleField_data = Core.Name "data"+_ModuleField_elem = Core.Name "elem"+_ModuleField_start = Core.Name "start"+-- | A WebAssembly value type+data ValType =+  -- | 32-bit integer+  ValTypeI32 |+  -- | 64-bit integer+  ValTypeI64 |+  -- | 32-bit float+  ValTypeF32 |+  -- | 64-bit float+  ValTypeF64 |+  -- | Function reference+  ValTypeFuncref |+  -- | External reference+  ValTypeExternref+  deriving (Eq, Ord, Read, Show)+_ValType = Core.Name "hydra.wasm.syntax.ValType"+_ValType_i32 = Core.Name "i32"+_ValType_i64 = Core.Name "i64"+_ValType_f32 = Core.Name "f32"+_ValType_f64 = Core.Name "f64"+_ValType_funcref = Core.Name "funcref"+_ValType_externref = Core.Name "externref"+-- | A function type signature+data FuncType =+  FuncType {+    -- | Parameter types+    funcTypeParams :: [ValType],+    -- | Result types+    funcTypeResults :: [ValType]}+  deriving (Eq, Ord, Read, Show)+_FuncType = Core.Name "hydra.wasm.syntax.FuncType"+_FuncType_params = Core.Name "params"+_FuncType_results = Core.Name "results"+-- | A reference to a function type, either by index or inline+data FuncTypeRef =+  -- | Reference by type index+  FuncTypeRefIndex String |+  -- | Inline function type+  FuncTypeRefInline FuncType+  deriving (Eq, Ord, Read, Show)+_FuncTypeRef = Core.Name "hydra.wasm.syntax.FuncTypeRef"+_FuncTypeRef_index = Core.Name "index"+_FuncTypeRef_inline = Core.Name "inline"+-- | A type use clause, referencing a type definition+data TypeUse =+  TypeUse {+    -- | Optional type index reference+    typeUseIndex :: (Maybe String),+    -- | Explicit parameter declarations (may augment or override type index)+    typeUseParams :: [Param],+    -- | Explicit result types+    typeUseResults :: [ValType]}+  deriving (Eq, Ord, Read, Show)+_TypeUse = Core.Name "hydra.wasm.syntax.TypeUse"+_TypeUse_index = Core.Name "index"+_TypeUse_params = Core.Name "params"+_TypeUse_results = Core.Name "results"+-- | A named type definition in the type section+data TypeDef =+  TypeDef {+    -- | Optional type name+    typeDefName :: (Maybe String),+    -- | The function type+    typeDefType :: FuncType}+  deriving (Eq, Ord, Read, Show)+_TypeDef = Core.Name "hydra.wasm.syntax.TypeDef"+_TypeDef_name = Core.Name "name"+_TypeDef_type = Core.Name "type"+-- | A function definition+data Func =+  Func {+    -- | Optional function name+    funcName :: (Maybe String),+    -- | The function's type signature+    funcTypeUse :: TypeUse,+    -- | Local variable declarations+    funcLocals :: [FuncLocal],+    -- | The function body (a sequence of instructions)+    funcBody :: [Instruction]}+  deriving (Eq, Ord, Read, Show)+_Func = Core.Name "hydra.wasm.syntax.Func"+_Func_name = Core.Name "name"+_Func_typeUse = Core.Name "typeUse"+_Func_locals = Core.Name "locals"+_Func_body = Core.Name "body"+-- | A local variable declaration within a function+data FuncLocal =+  FuncLocal {+    -- | Optional local name+    funcLocalName :: (Maybe String),+    -- | The local's value type+    funcLocalType :: ValType}+  deriving (Eq, Ord, Read, Show)+_FuncLocal = Core.Name "hydra.wasm.syntax.FuncLocal"+_FuncLocal_name = Core.Name "name"+_FuncLocal_type = Core.Name "type"+-- | A function parameter declaration+data Param =+  Param {+    -- | Optional parameter name+    paramName :: (Maybe String),+    -- | The parameter's value type+    paramType :: ValType}+  deriving (Eq, Ord, Read, Show)+_Param = Core.Name "hydra.wasm.syntax.Param"+_Param_name = Core.Name "name"+_Param_type = Core.Name "type"+-- | Arguments for a branch table instruction+data BrTableArgs =+  BrTableArgs {+    -- | Branch target labels+    brTableArgsLabels :: [String],+    -- | Default branch target+    brTableArgsDefault :: String}+  deriving (Eq, Ord, Read, Show)+_BrTableArgs = Core.Name "hydra.wasm.syntax.BrTableArgs"+_BrTableArgs_labels = Core.Name "labels"+_BrTableArgs_default = Core.Name "default"+-- | A WebAssembly instruction+data Instruction =+  -- | Push a constant value+  InstructionConst ConstValue |+  -- | Get local variable by name or index+  InstructionLocalGet String |+  -- | Set local variable by name or index+  InstructionLocalSet String |+  -- | Set local variable and keep value on stack+  InstructionLocalTee String |+  -- | Get global variable by name or index+  InstructionGlobalGet String |+  -- | Set global variable by name or index+  InstructionGlobalSet String |+  -- | Load from memory (e.g., i32.load, f64.load)+  InstructionLoad MemoryInstruction |+  -- | Store to memory (e.g., i32.store, f64.store)+  InstructionStore MemoryInstruction |+  -- | Unary numeric operation (e.g., i32.clz, f64.neg)+  InstructionUnop NumericOp |+  -- | Binary numeric operation (e.g., i32.add, f64.mul)+  InstructionBinop NumericOp |+  -- | Test operation (e.g., i32.eqz)+  InstructionTestop NumericOp |+  -- | Comparison operation (e.g., i32.eq, f64.lt)+  InstructionRelop NumericOp |+  -- | Type conversion (e.g., i32.wrap_i64, f64.convert_i32_s)+  InstructionConvert String |+  -- | Call a function by name or index+  InstructionCall String |+  -- | Indirect function call through a table+  InstructionCallIndirect TypeUse |+  -- | A block instruction+  InstructionBlock BlockInstruction |+  -- | A loop instruction+  InstructionLoop BlockInstruction |+  -- | An if-then-else instruction+  InstructionIf IfInstruction |+  -- | Branch to a label+  InstructionBr String |+  -- | Conditional branch to a label+  InstructionBrIf String |+  -- | Branch table+  InstructionBrTable BrTableArgs |+  -- | Return from the current function+  InstructionReturn |+  -- | Drop the top value from the stack+  InstructionDrop |+  -- | Select one of two values based on a condition+  InstructionSelect |+  -- | Trap immediately+  InstructionUnreachable |+  -- | No operation+  InstructionNop |+  -- | Get current memory size in pages+  InstructionMemorySize |+  -- | Grow memory by a number of pages+  InstructionMemoryGrow |+  -- | Null reference of the given type+  InstructionRefNull RefType |+  -- | Test if a reference is null+  InstructionRefIsNull |+  -- | A raw WAT instruction string (escape hatch)+  InstructionRaw String+  deriving (Eq, Ord, Read, Show)+_Instruction = Core.Name "hydra.wasm.syntax.Instruction"+_Instruction_const = Core.Name "const"+_Instruction_localGet = Core.Name "localGet"+_Instruction_localSet = Core.Name "localSet"+_Instruction_localTee = Core.Name "localTee"+_Instruction_globalGet = Core.Name "globalGet"+_Instruction_globalSet = Core.Name "globalSet"+_Instruction_load = Core.Name "load"+_Instruction_store = Core.Name "store"+_Instruction_unop = Core.Name "unop"+_Instruction_binop = Core.Name "binop"+_Instruction_testop = Core.Name "testop"+_Instruction_relop = Core.Name "relop"+_Instruction_convert = Core.Name "convert"+_Instruction_call = Core.Name "call"+_Instruction_callIndirect = Core.Name "callIndirect"+_Instruction_block = Core.Name "block"+_Instruction_loop = Core.Name "loop"+_Instruction_if = Core.Name "if"+_Instruction_br = Core.Name "br"+_Instruction_brIf = Core.Name "brIf"+_Instruction_brTable = Core.Name "brTable"+_Instruction_return = Core.Name "return"+_Instruction_drop = Core.Name "drop"+_Instruction_select = Core.Name "select"+_Instruction_unreachable = Core.Name "unreachable"+_Instruction_nop = Core.Name "nop"+_Instruction_memorySize = Core.Name "memorySize"+_Instruction_memoryGrow = Core.Name "memoryGrow"+_Instruction_refNull = Core.Name "refNull"+_Instruction_refIsNull = Core.Name "refIsNull"+_Instruction_raw = Core.Name "raw"+-- | A block or loop instruction with a label and body+data BlockInstruction =+  BlockInstruction {+    -- | Optional block label+    blockInstructionLabel :: (Maybe String),+    -- | The block's result type+    blockInstructionBlockType :: BlockType,+    -- | The instructions in the block+    blockInstructionBody :: [Instruction]}+  deriving (Eq, Ord, Read, Show)+_BlockInstruction = Core.Name "hydra.wasm.syntax.BlockInstruction"+_BlockInstruction_label = Core.Name "label"+_BlockInstruction_blockType = Core.Name "blockType"+_BlockInstruction_body = Core.Name "body"+-- | The type of a block, loop, or if instruction+data BlockType =+  -- | No result+  BlockTypeEmpty |+  -- | Single result value type+  BlockTypeValue ValType |+  -- | Full function type signature+  BlockTypeTypeUse TypeUse+  deriving (Eq, Ord, Read, Show)+_BlockType = Core.Name "hydra.wasm.syntax.BlockType"+_BlockType_empty = Core.Name "empty"+_BlockType_value = Core.Name "value"+_BlockType_typeUse = Core.Name "typeUse"+-- | Memory access arguments+data MemArg =+  MemArg {+    -- | Memory offset in bytes+    memArgOffset :: Int,+    -- | Alignment hint (power of 2)+    memArgAlign :: Int}+  deriving (Eq, Ord, Read, Show)+_MemArg = Core.Name "hydra.wasm.syntax.MemArg"+_MemArg_offset = Core.Name "offset"+_MemArg_align = Core.Name "align"+-- | A memory load or store instruction+data MemoryInstruction =+  MemoryInstruction {+    -- | Value type to load or store+    memoryInstructionType :: ValType,+    -- | Memory argument (offset and alignment)+    memoryInstructionMemArg :: MemArg}+  deriving (Eq, Ord, Read, Show)+_MemoryInstruction = Core.Name "hydra.wasm.syntax.MemoryInstruction"+_MemoryInstruction_type = Core.Name "type"+_MemoryInstruction_memArg = Core.Name "memArg"+-- | An if-then-else instruction+data IfInstruction =+  IfInstruction {+    -- | Optional label for the if block+    ifInstructionLabel :: (Maybe String),+    -- | The result type of the if+    ifInstructionBlockType :: BlockType,+    -- | The 'then' branch instructions+    ifInstructionThen :: [Instruction],+    -- | The 'else' branch instructions (may be empty)+    ifInstructionElse :: [Instruction]}+  deriving (Eq, Ord, Read, Show)+_IfInstruction = Core.Name "hydra.wasm.syntax.IfInstruction"+_IfInstruction_label = Core.Name "label"+_IfInstruction_blockType = Core.Name "blockType"+_IfInstruction_then = Core.Name "then"+_IfInstruction_else = Core.Name "else"+-- | A typed numeric operation (used for unop, binop, testop, relop)+data NumericOp =+  NumericOp {+    -- | Operand value type+    numericOpType :: ValType,+    -- | Operation name (e.g., add, sub, mul, eqz, lt_s)+    numericOpName :: String}+  deriving (Eq, Ord, Read, Show)+_NumericOp = Core.Name "hydra.wasm.syntax.NumericOp"+_NumericOp_type = Core.Name "type"+_NumericOp_name = Core.Name "name"+-- | A memory definition+data MemoryDef =+  MemoryDef {+    -- | Optional memory name+    memoryDefName :: (Maybe String),+    -- | Memory size limits (in pages of 64KB)+    memoryDefLimits :: Limits}+  deriving (Eq, Ord, Read, Show)+_MemoryDef = Core.Name "hydra.wasm.syntax.MemoryDef"+_MemoryDef_name = Core.Name "name"+_MemoryDef_limits = Core.Name "limits"+-- | A data segment for initializing memory+data DataSegment =+  DataSegment {+    -- | Optional data segment name+    dataSegmentName :: (Maybe String),+    -- | Whether this is an active or passive data segment+    dataSegmentMode :: DataMode,+    -- | The data bytes (as a string of escaped bytes)+    dataSegmentBytes :: String}+  deriving (Eq, Ord, Read, Show)+_DataSegment = Core.Name "hydra.wasm.syntax.DataSegment"+_DataSegment_name = Core.Name "name"+_DataSegment_mode = Core.Name "mode"+_DataSegment_bytes = Core.Name "bytes"+-- | The mode of a data segment+data DataMode =+  -- | Active segment: loaded at the given offset expression+  DataModeActive [Instruction] |+  -- | Passive segment: must be explicitly loaded via memory.init+  DataModePassive+  deriving (Eq, Ord, Read, Show)+_DataMode = Core.Name "hydra.wasm.syntax.DataMode"+_DataMode_active = Core.Name "active"+_DataMode_passive = Core.Name "passive"+-- | Size limits for memories and tables+data Limits =+  Limits {+    -- | Minimum size+    limitsMin :: Int,+    -- | Optional maximum size+    limitsMax :: (Maybe Int)}+  deriving (Eq, Ord, Read, Show)+_Limits = Core.Name "hydra.wasm.syntax.Limits"+_Limits_min = Core.Name "min"+_Limits_max = Core.Name "max"+-- | A global variable definition+data GlobalDef =+  GlobalDef {+    -- | Optional global name+    globalDefName :: (Maybe String),+    -- | The global's type (value type and mutability)+    globalDefType :: GlobalType,+    -- | Initialization expression+    globalDefInit :: [Instruction]}+  deriving (Eq, Ord, Read, Show)+_GlobalDef = Core.Name "hydra.wasm.syntax.GlobalDef"+_GlobalDef_name = Core.Name "name"+_GlobalDef_type = Core.Name "type"+_GlobalDef_init = Core.Name "init"+-- | A global variable type+data GlobalType =+  GlobalType {+    -- | The value type+    globalTypeValType :: ValType,+    -- | Whether the global is mutable+    globalTypeMutable :: Bool}+  deriving (Eq, Ord, Read, Show)+_GlobalType = Core.Name "hydra.wasm.syntax.GlobalType"+_GlobalType_valType = Core.Name "valType"+_GlobalType_mutable = Core.Name "mutable"+-- | A table definition+data TableDef =+  TableDef {+    -- | Optional table name+    tableDefName :: (Maybe String),+    -- | The reference type of table elements+    tableDefRefType :: RefType,+    -- | Table size limits+    tableDefLimits :: Limits}+  deriving (Eq, Ord, Read, Show)+_TableDef = Core.Name "hydra.wasm.syntax.TableDef"+_TableDef_name = Core.Name "name"+_TableDef_refType = Core.Name "refType"+_TableDef_limits = Core.Name "limits"+-- | Active element segment parameters+data ElemActive =+  ElemActive {+    -- | Table index+    elemActiveTable :: String,+    -- | Offset expression+    elemActiveOffset :: [Instruction]}+  deriving (Eq, Ord, Read, Show)+_ElemActive = Core.Name "hydra.wasm.syntax.ElemActive"+_ElemActive_table = Core.Name "table"+_ElemActive_offset = Core.Name "offset"+-- | An element segment for initializing tables+data ElemSegment =+  ElemSegment {+    -- | Optional element segment name+    elemSegmentName :: (Maybe String),+    -- | Whether this is an active or passive element segment+    elemSegmentMode :: ElemMode,+    -- | The reference type of elements+    elemSegmentType :: RefType,+    -- | Initialization expressions (one per element)+    elemSegmentInit :: [[Instruction]]}+  deriving (Eq, Ord, Read, Show)+_ElemSegment = Core.Name "hydra.wasm.syntax.ElemSegment"+_ElemSegment_name = Core.Name "name"+_ElemSegment_mode = Core.Name "mode"+_ElemSegment_type = Core.Name "type"+_ElemSegment_init = Core.Name "init"+-- | The mode of an element segment+data ElemMode =+  -- | Active segment: loaded at the given table index and offset+  ElemModeActive ElemActive |+  -- | Passive segment: must be explicitly loaded via table.init+  ElemModePassive |+  -- | Declarative segment: declares function references for ref.func+  ElemModeDeclarative+  deriving (Eq, Ord, Read, Show)+_ElemMode = Core.Name "hydra.wasm.syntax.ElemMode"+_ElemMode_active = Core.Name "active"+_ElemMode_passive = Core.Name "passive"+_ElemMode_declarative = Core.Name "declarative"+-- | A reference type for tables and reference instructions+data RefType =+  -- | Function reference+  RefTypeFuncref |+  -- | External reference+  RefTypeExternref+  deriving (Eq, Ord, Read, Show)+_RefType = Core.Name "hydra.wasm.syntax.RefType"+_RefType_funcref = Core.Name "funcref"+_RefType_externref = Core.Name "externref"+-- | An import declaration+data ImportDef =+  ImportDef {+    -- | The module name to import from+    importDefModule :: String,+    -- | The name of the imported entity+    importDefName :: String,+    -- | The import descriptor (what kind of entity is imported)+    importDefDesc :: ImportDesc}+  deriving (Eq, Ord, Read, Show)+_ImportDef = Core.Name "hydra.wasm.syntax.ImportDef"+_ImportDef_module = Core.Name "module"+_ImportDef_name = Core.Name "name"+_ImportDef_desc = Core.Name "desc"+-- | An import descriptor specifying the kind of imported entity+data ImportDesc =+  -- | Import a function with the given type+  ImportDescFunc ImportFunc |+  -- | Import a memory with the given limits+  ImportDescMemory ImportMemory |+  -- | Import a table+  ImportDescTable ImportTable |+  -- | Import a global variable+  ImportDescGlobal ImportGlobal+  deriving (Eq, Ord, Read, Show)+_ImportDesc = Core.Name "hydra.wasm.syntax.ImportDesc"+_ImportDesc_func = Core.Name "func"+_ImportDesc_memory = Core.Name "memory"+_ImportDesc_table = Core.Name "table"+_ImportDesc_global = Core.Name "global"+-- | A function import descriptor+data ImportFunc =+  ImportFunc {+    -- | Optional local name for the imported function+    importFuncName :: (Maybe String),+    -- | The function's type+    importFuncTypeUse :: TypeUse}+  deriving (Eq, Ord, Read, Show)+_ImportFunc = Core.Name "hydra.wasm.syntax.ImportFunc"+_ImportFunc_name = Core.Name "name"+_ImportFunc_typeUse = Core.Name "typeUse"+-- | A global import descriptor+data ImportGlobal =+  ImportGlobal {+    -- | Optional local name+    importGlobalName :: (Maybe String),+    -- | Global type+    importGlobalType :: GlobalType}+  deriving (Eq, Ord, Read, Show)+_ImportGlobal = Core.Name "hydra.wasm.syntax.ImportGlobal"+_ImportGlobal_name = Core.Name "name"+_ImportGlobal_type = Core.Name "type"+-- | A memory import descriptor+data ImportMemory =+  ImportMemory {+    -- | Optional local name+    importMemoryName :: (Maybe String),+    -- | Memory limits+    importMemoryLimits :: Limits}+  deriving (Eq, Ord, Read, Show)+_ImportMemory = Core.Name "hydra.wasm.syntax.ImportMemory"+_ImportMemory_name = Core.Name "name"+_ImportMemory_limits = Core.Name "limits"+-- | A table import descriptor+data ImportTable =+  ImportTable {+    -- | Optional local name+    importTableName :: (Maybe String),+    -- | Reference type+    importTableRefType :: RefType,+    -- | Table limits+    importTableLimits :: Limits}+  deriving (Eq, Ord, Read, Show)+_ImportTable = Core.Name "hydra.wasm.syntax.ImportTable"+_ImportTable_name = Core.Name "name"+_ImportTable_refType = Core.Name "refType"+_ImportTable_limits = Core.Name "limits"+-- | An export declaration+data ExportDef =+  ExportDef {+    -- | The exported name+    exportDefName :: String,+    -- | What is being exported+    exportDefDesc :: ExportDesc}+  deriving (Eq, Ord, Read, Show)+_ExportDef = Core.Name "hydra.wasm.syntax.ExportDef"+_ExportDef_name = Core.Name "name"+_ExportDef_desc = Core.Name "desc"+-- | An export descriptor identifying what is being exported+data ExportDesc =+  -- | Export a function by name or index+  ExportDescFunc String |+  -- | Export a memory by name or index+  ExportDescMemory String |+  -- | Export a table by name or index+  ExportDescTable String |+  -- | Export a global by name or index+  ExportDescGlobal String+  deriving (Eq, Ord, Read, Show)+_ExportDesc = Core.Name "hydra.wasm.syntax.ExportDesc"+_ExportDesc_func = Core.Name "func"+_ExportDesc_memory = Core.Name "memory"+_ExportDesc_table = Core.Name "table"+_ExportDesc_global = Core.Name "global"+-- | A constant value instruction+data ConstValue =+  -- | A 32-bit integer constant+  ConstValueI32 Int |+  -- | A 64-bit integer constant+  ConstValueI64 I.Int64 |+  -- | A 32-bit float constant+  ConstValueF32 Float |+  -- | A 64-bit float constant+  ConstValueF64 Double+  deriving (Eq, Ord, Read, Show)+_ConstValue = Core.Name "hydra.wasm.syntax.ConstValue"+_ConstValue_i32 = Core.Name "i32"+_ConstValue_i64 = Core.Name "i64"+_ConstValue_f32 = Core.Name "f32"+_ConstValue_f64 = Core.Name "f64"