diff --git a/README.md b/README.md deleted file mode 100644 --- a/README.md +++ /dev/null @@ -1,414 +0,0 @@ -# Hydra-Haskell - -Hydra is a functional programming language based on the [LambdaGraph](https://bit.ly/lg-kgc2024) data model, -exploring an isomorphism between typed lambda calculus and labeled hypergraphs. -See the main Hydra [README](https://github.com/CategoricalData/hydra) for project overview and use cases. - -This package contains Hydra's **Haskell implementation**, -which serves as the bootstrapping implementation for the entire Hydra project. -Releases are available [on Hackage](https://hackage.haskell.org/package/hydra). - -## Code Organization - -Hydra-Haskell uses the **src/main vs src/gen-main** separation pattern -(see [Code organization wiki page](https://github.com/CategoricalData/hydra/wiki/Code-organization) for details). - -- **`src/main/haskell/`** - Hand-written source code - - `Hydra/Dsl/` - DSL syntax definitions - - `Hydra/Sources/` - Kernel specifications written in the DSL - - `Hydra/Lib/` - Native primitive implementations - - `Hydra/Generation.hs` - Code generation utilities - -- **`src/gen-main/haskell/`** - Generated code - - `Hydra/Core.hs`, `Hydra/Graph.hs`, etc. - Complete kernel implementation - - Generated by running `writeHaskell` in GHCi - -- **`src/gen-test/haskell/`** - Generated test code - - Kernel tests generated from test sources using `writeHaskell` - - Generation tests created using language-specific test generators - - See [Testing](#test) section for details - -Haskell serves as the **bootstrapping implementation** - -the DSL sources here generate code for Java, Python, Scala, Lisp, and other languages. - -## Documentation - -For comprehensive documentation about Hydra's architecture, type system, -and implementation details, see: - -- **[Concepts](https://github.com/CategoricalData/hydra/wiki/Concepts)** - - Core concepts: Type, Term, Graph, Flow monad, primitives, coders -- **[Implementation](https://github.com/CategoricalData/hydra/blob/main/docs/implementation.md)** - - Detailed guide covering type modules, DSLs, primitives, coders, and the bootstrap process -- **[DSL Guide](https://github.com/CategoricalData/hydra/blob/main/docs/dsl-guide.md)** - - Comprehensive guide to Hydra's domain-specific languages -- **[Code Organization](https://github.com/CategoricalData/hydra/wiki/Code-organization)** - - The src/main vs src/gen-main pattern -- **[Testing](https://github.com/CategoricalData/hydra/wiki/Testing)** - - Common test suite and language-specific testing -- **[Developer Recipes](https://github.com/CategoricalData/hydra/blob/main/docs/recipes/index.md)** - - Step-by-step guides for extending Hydra - -This README focuses on practical instructions for building, testing, and generating code with Hydra-Haskell. - -## Build - -Haskell is Hydra's **bootstrapping language**. -The entire Hydra kernel is written using Haskell-based domain-specific languages (DSLs): -- **DSL syntax**: - [src/main/haskell/Hydra/Dsl](https://github.com/CategoricalData/hydra/tree/main/hydra-haskell/src/main/haskell/Hydra/Dsl) - - Specify the syntax for Hydra programs written in Haskell -- **DSL-based sources**: - [src/main/haskell/Hydra/Sources](https://github.com/CategoricalData/hydra/tree/main/hydra-haskell/src/main/haskell/Hydra/Sources) - - Type definitions and core logic written in Haskell DSL -- **Generated code**: - [src/gen-main/haskell](https://github.com/CategoricalData/hydra/tree/main/hydra-haskell/src/gen-main/haskell) - - Haskell code generated from DSL sources -- **Primitives**: - [src/main/haskell/Hydra/Lib](https://github.com/CategoricalData/hydra/tree/main/hydra-haskell/src/main/haskell/Hydra/Lib) - - Hydra's standard libraries of primitive functions and constants, implemented in Haskell. - These libraries are registered in - [Libraries.hs](https://github.com/CategoricalData/hydra/tree/main/hydra-haskell/src/main/haskell/Hydra/Sources/Libraries.hs). - -The DSL sources are also used to generate Java and Python implementations, -ensuring parity across each Hydra language variant. - -### Build and REPL - -First, install the [Haskell Tool Stack](https://docs.haskellstack.org/en/stable): - -```bash -# On macOS -brew install haskell-stack - -# Other platforms: see https://docs.haskellstack.org/en/stable/install_and_upgrade/ -``` - -Then build and enter the GHCi REPL: - -```bash -stack ghci hydra:lib -``` - -Note: The `hydra:lib` target is required to avoid loading test modules. -Running `stack ghci` without a target will load all components including test dependencies, -which you may not need. - -## Test - -Run all tests: - -```bash -stack test -``` - -For interactive testing with access to test utilities: - -```bash -stack ghci hydra:lib hydra:hydra-test -``` - -Then in the REPL, you can run individual tests: - -```haskell -Test.Hspec.hspec Hydra.TestSuiteSpec.spec -``` - -See the [Testing wiki page](https://github.com/CategoricalData/hydra/wiki/Testing) -for details on Hydra's common test suite, which ensures parity across all Hydra language variants. - -## Code generation - -Hydra is **self-hosting**: it can generate its own source code from DSL definitions. - -### Generate Haskell code - -Enter the GHCi REPL and import the generation module: - -```haskell -import Hydra.Generation -``` - -Generate all main modules provided in Hydra-Haskell: - -```haskell --- First arg: output directory --- Second arg: universe modules (for dependency resolution) --- Third arg: modules to generate -writeHaskell "src/gen-main/haskell" mainModules mainModules -``` - -Generate only the Hydra kernel (excluding other Hydra-Haskell artifacts like the Haskell coder, the JSON coder, etc.): - -```haskell -writeHaskell "src/gen-main/haskell" kernelModules kernelModules -``` - -Generate specific main modules: - -```haskell --- For specific modules, include dependencies in the universe -writeHaskell "src/gen-main/haskell" mainModules [haskellLanguageModule, haskellCoderModule] -``` - -Generate kernel test modules: - -```haskell -let allModules = mainModules ++ testModules -writeHaskell "src/gen-test/haskell" allModules baseTestModules -``` - -Or use the convenience script: - -```bash -./bin/update-kernel-tests.sh -``` - -This generates tests that validate the Hydra kernel implementation. - -Generate language-specific generation tests (tests that verify code generation to Haskell): - -```bash -./bin/update-generation-tests.sh -``` - -These two types of tests serve different purposes: -- **Kernel tests**: Validate core Hydra functionality (type checking, reduction, etc.) -- **Generation tests**: Verify that Hydra can correctly generate code in target languages - -Note `src/gen-test` as opposed to `src/gen-main`. - -### Generate code for other languages - -Java and Python code generation is handled by the -[Hydra-Ext](https://github.com/CategoricalData/hydra/tree/main/hydra-ext) package. -From the `hydra-ext` directory: - -```bash -cd ../hydra-ext && stack ghci -``` - -Then in GHCi: - -```haskell -import Hydra.Ext.Generation - --- Generate Python kernel --- Second arg: universe modules (for dependency resolution) --- Third arg: modules to generate -writePython "../hydra-python/src/gen-main/python" kernelModules kernelModules - --- Generate Java kernel -writeJava "../hydra-java/src/gen-main/java" kernelModules kernelModules -``` - -And similar for test artifacts. See the Hydra-Ext README for more details. -Hydra-Ext also includes coders for many other languages and formats: -Avro, Protobuf, C++, C#, Scala, GraphQL, JSON Schema, RDF, and more. - -## Working with Hydra - -### Core types - -Some of the fundamental types in Hydra are: - -- **`Type`** - Represents the structure of data (literals, records, unions, functions, etc.) -- **`Term`** - Represents data or computation (instances of types) -- **`Binding`** - A named binding (name + term + type scheme), also called an *element*. -- **`Graph`** - A collection of elements with an environment, types, primitives, and schema graph -- **`Module`** - A namespace containing elements with dependencies on other modules - -These are defined in -[Hydra/Sources/Kernel/Types](https://github.com/CategoricalData/hydra/tree/main/hydra-haskell/src/main/haskell/Hydra/Sources/Kernel/Types) -and code-generated into -[Hydra.Core](https://github.com/CategoricalData/hydra/blob/main/hydra-haskell/src/gen-main/haskell/Hydra/Core.hs), -[Hydra.Graph](https://github.com/CategoricalData/hydra/blob/main/hydra-haskell/src/gen-main/haskell/Hydra/Graph.hs), and -[Hydra.Module](https://github.com/CategoricalData/hydra/blob/main/hydra-haskell/src/gen-main/haskell/Hydra/Module.hs). - -See [Concepts](https://github.com/CategoricalData/hydra/wiki/Concepts) for detailed explanations. - -### Error handling and Context - -Hydra uses `Either (InContext OtherError) a` for computations that can fail, -where `InContext` pairs an error with a `Context` carrying debug traces and metadata. -Graph and Context are passed as explicit parameters. - -```haskell --- A function that may fail -myComputation :: Context -> Graph -> Either (InContext OtherError) String -myComputation cx g = Right "result" - --- Execute it -case myComputation emptyContext myGraph of - Right result -> putStrLn result - Left ic -> print (unOtherError (inContextObject ic)) -``` - -### Coders and adapters - -**Coders** are bidirectional transformations: - -```haskell -data Coder v1 v2 = Coder { - coderEncode :: v1 -> Context -> Graph -> Either (InContext OtherError) v2, - coderDecode :: v2 -> Context -> Graph -> Either (InContext OtherError) v1 -} -``` - -**Adapters** also transform types, enabling schema evolution and language mapping. - -See the -[Implementation wiki](https://github.com/CategoricalData/hydra/blob/main/docs/implementation.md#cross-language-compilation-coders) -for details. - -### DSLs - -Hydra provides multiple domain-specific languages for constructing types and terms: - -**Untyped DSLs** -([Hydra/Dsl/Types.hs](https://github.com/CategoricalData/hydra/blob/main/hydra-haskell/src/main/haskell/Hydra/Dsl/Types.hs), -[Hydra/Dsl/Terms.hs](https://github.com/CategoricalData/hydra/blob/main/hydra-haskell/src/main/haskell/Hydra/Dsl/Terms.hs)): -```haskell -import qualified Hydra.Dsl.Types as Types -import qualified Hydra.Dsl.Terms as Terms - -personType = Types.record [ - "name" >: string, - "age" >: int32] - -alice = Terms.record [ - "name" >: Terms.string "Alice", - "age" >: Terms.int32 30] -``` - -**Phantom-typed DSLs** -([Hydra/Dsl/Meta/Phantoms.hs](https://github.com/CategoricalData/hydra/blob/main/hydra-haskell/src/main/haskell/Hydra/Dsl/Meta/Phantoms.hs)) - -Compile-time type safety: -```haskell -import Hydra.Dsl.Meta.Phantoms - -safeFn :: TTerm (Int -> String) -safeFn = lambda "x" (Strings.toUpper (var "x")) -- Type-checked at compile time -``` - -**Library DSLs** -([Hydra/Dsl/Meta/Lib](https://github.com/CategoricalData/hydra/tree/main/hydra-haskell/src/main/haskell/Hydra/Dsl/Meta/Lib)) - -Wrappers for primitive functions: -```haskell -import Hydra.Dsl.Meta.Lib.Lists as Lists -import Hydra.Dsl.Meta.Lib.Strings as Strings - -example = Lists.map (Strings.toUpper) (list ["hello", "world"]) -``` - -See the [DSL system section](https://github.com/CategoricalData/hydra/blob/main/docs/implementation.md#dsl-system) -in the Implementation wiki for comprehensive coverage. - -### JSON and YAML serialization - -Serialize Hydra terms to JSON or YAML: - -```haskell -import Hydra.Kernel -import Hydra.Codegen -import Hydra.Langs.Json.Serde -import Hydra.Dsl.Terms as Terms - --- Get the Hydra core graph -let g = hydraCoreGraph -let flow = fromFlowIo g - --- Define a type -let typ = TypeVariable _Precision - --- Create a term of that type -let term = Terms.inject _Precision (Field _Precision_bits $ Terms.int32 64) - --- Create a JSON coder for the type -coder <- flow $ jsonStringCoder typ - --- Encode to JSON -result <- flow (coderEncode coder term) -putStrLn result -``` - -## Self-hosting demonstration - -Hydra-Haskell is a [self-hosting compiler](https://en.wikipedia.org/wiki/Self-hosting_(compilers)) - -it can generate its own source code. - -Complete self-hosting cycle: - -```bash -# Generate all kernel code -stack ghci hydra:lib -import Hydra.Sources.All -import Hydra.Generation -writeHaskell "src/gen-main/haskell" mainModules mainModules -:q - -# Generate kernel tests -./bin/update-kernel-tests.sh - -# Generate language-specific generation tests -./bin/update-generation-tests.sh - -# Run all tests -stack test -``` - -Alternatively, use GHCi for all generation steps: - -```bash -stack ghci hydra:lib -import Hydra.Sources.All -import Hydra.Generation -writeHaskell "src/gen-main/haskell" mainModules mainModules -let allModules = mainModules ++ testModules -writeHaskell "src/gen-test/haskell" allModules baseTestModules -:q -stack test -``` - -The generated code includes: -- All core types (Type, Term, Graph, Module, etc.) -- Type inference and checking -- Term reduction and rewriting -- Coders and adapters -- Primitive functions (signatures only; implementations are in Hydra/Lib) - -What remains hand-written: -- `Hydra.Lib` - Native primitive implementations -- `Hydra.Sources` - DSL-based specifications (input to code generation) -- `Hydra.Dsl` - DSL syntax -- `Hydra.Generation` - I/O and generation utilities -- Test runners - -See the -[Bootstrap process](https://github.com/CategoricalData/hydra/blob/main/docs/implementation.md#the-bootstrap-process) -section for details on extending Hydra. -For example: -- [Adding new primitive functions](https://github.com/CategoricalData/hydra/blob/main/docs/recipes/adding-primitives.md) -- [Extending Hydra Core](https://github.com/CategoricalData/hydra/blob/main/docs/recipes/extending-hydra-core.md) - -## Troubleshooting - -### Stack version warnings - -If you see warnings like: -``` -Stack has not been tested with GHC versions above 9.0, and using 9.10.2, this may fail -Stack has not been tested with Cabal versions above 3.4, but version 3.12.1.0 was found, this may fail -``` - -**Solution:** Update Stack to the latest version: -```bash -stack upgrade -# or on macOS with Homebrew: -brew upgrade stack -``` - -**Explanation:** These are compatibility warnings that appear when using newer GHC/Cabal versions. -If your builds complete successfully, the warnings are harmless - -Stack works fine with newer versions even before official testing. -Upgrading Stack eliminates the warnings. diff --git a/hydra.cabal b/hydra.cabal --- a/hydra.cabal +++ b/hydra.cabal @@ -5,924 +5,1228 @@ -- see: https://github.com/sol/hpack name: hydra -version: 0.14.0 -synopsis: Graph programming language -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". The language is designed to be embedded in other programming languages -- currently Haskell, Java, and Python. Hydra transforms data, schemas, and functional programs into multiple other languages in a way which maintains type safety. It is mutually self-hosting in Haskell, Java, and Python; i.e. each Hydra compiler can generate each other Hydra compiler as well as itself. -category: Data -homepage: https://github.com/CategoricalData/hydra#readme -bug-reports: https://github.com/CategoricalData/hydra/issues -author: Joshua Shinavier -maintainer: Joshua Shinavier -license: Apache-2.0 -license-file: LICENSE -build-type: Simple -extra-source-files: - LICENSE - README.md - stack.yaml - -source-repository head - type: git - location: https://github.com/CategoricalData/hydra - -library - exposed-modules: - Hydra.Dsl.Annotations - Hydra.Dsl.AsTerm - Hydra.Dsl.AsType - Hydra.Dsl.Bootstrap - Hydra.Dsl.Literals - Hydra.Dsl.LiteralTypes - Hydra.Dsl.Meta.Base - Hydra.Dsl.Meta.Common - Hydra.Dsl.Meta.Context - Hydra.Dsl.Meta.Core - Hydra.Dsl.Meta.DeepCore - Hydra.Dsl.Meta.Graph - Hydra.Dsl.Meta.Lib.Chars - Hydra.Dsl.Meta.Lib.Eithers - Hydra.Dsl.Meta.Lib.Equality - Hydra.Dsl.Meta.Lib.Lists - Hydra.Dsl.Meta.Lib.Literals - Hydra.Dsl.Meta.Lib.Logic - Hydra.Dsl.Meta.Lib.Maps - Hydra.Dsl.Meta.Lib.Math - Hydra.Dsl.Meta.Lib.Maybes - Hydra.Dsl.Meta.Lib.Pairs - Hydra.Dsl.Meta.Lib.Regex - Hydra.Dsl.Meta.Lib.Sets - Hydra.Dsl.Meta.Lib.Strings - Hydra.Dsl.Meta.Literals - Hydra.Dsl.Meta.Phantoms - Hydra.Dsl.Meta.Tabular - Hydra.Dsl.Meta.Terms - Hydra.Dsl.Meta.Testing - Hydra.Dsl.Meta.Types - Hydra.Dsl.Meta.Variants - Hydra.Dsl.Prims - Hydra.Dsl.Terms - Hydra.Dsl.Tests - Hydra.Dsl.Types - Hydra.Ext.Haskell.TestingIo - Hydra.Generation - Hydra.Kernel - Hydra.Lib.Chars - Hydra.Lib.Eithers - Hydra.Lib.Equality - Hydra.Lib.Lists - Hydra.Lib.Literals - Hydra.Lib.Logic - Hydra.Lib.Maps - Hydra.Lib.Math - Hydra.Lib.Maybes - Hydra.Lib.Pairs - Hydra.Lib.Regex - Hydra.Lib.Sets - Hydra.Lib.Strings - Hydra.Minimal - Hydra.Module.Compat - Hydra.Settings - Hydra.Sources.All - Hydra.Sources.CoderUtils - Hydra.Sources.Eval.Lib.All - Hydra.Sources.Eval.Lib.Eithers - Hydra.Sources.Eval.Lib.Equality - Hydra.Sources.Eval.Lib.Lists - Hydra.Sources.Eval.Lib.Logic - Hydra.Sources.Eval.Lib.Maps - Hydra.Sources.Eval.Lib.Math - Hydra.Sources.Eval.Lib.Maybes - Hydra.Sources.Eval.Lib.Pairs - Hydra.Sources.Eval.Lib.Sets - Hydra.Sources.Haskell.Coder - Hydra.Sources.Haskell.Language - Hydra.Sources.Haskell.Operators - Hydra.Sources.Haskell.Serde - Hydra.Sources.Haskell.Syntax - Hydra.Sources.Haskell.Testing - Hydra.Sources.Haskell.Utils - Hydra.Sources.Json.Bootstrap - Hydra.Sources.Json.Decode - Hydra.Sources.Json.Decoding - Hydra.Sources.Json.Encode - Hydra.Sources.Json.Extract - Hydra.Sources.Json.Model - Hydra.Sources.Json.Parser - Hydra.Sources.Json.Writer - Hydra.Sources.Json.Yaml.Decode - Hydra.Sources.Json.Yaml.Encode - Hydra.Sources.Kernel.Lib.Names - Hydra.Sources.Kernel.Terms.Adapt - Hydra.Sources.Kernel.Terms.All - Hydra.Sources.Kernel.Terms.Annotations - Hydra.Sources.Kernel.Terms.Arity - Hydra.Sources.Kernel.Terms.Checking - Hydra.Sources.Kernel.Terms.CodeGeneration - Hydra.Sources.Kernel.Terms.Constants - Hydra.Sources.Kernel.Terms.Decoding - Hydra.Sources.Kernel.Terms.Dsls - Hydra.Sources.Kernel.Terms.Encoding - Hydra.Sources.Kernel.Terms.Extract.Core - Hydra.Sources.Kernel.Terms.Extract.Helpers - Hydra.Sources.Kernel.Terms.Extract.Util - Hydra.Sources.Kernel.Terms.Formatting - Hydra.Sources.Kernel.Terms.Hoisting - Hydra.Sources.Kernel.Terms.Inference - Hydra.Sources.Kernel.Terms.Languages - Hydra.Sources.Kernel.Terms.Lexical - Hydra.Sources.Kernel.Terms.Literals - Hydra.Sources.Kernel.Terms.Names - Hydra.Sources.Kernel.Terms.Parsers - Hydra.Sources.Kernel.Terms.Reduction - Hydra.Sources.Kernel.Terms.Reflect - Hydra.Sources.Kernel.Terms.Rewriting - Hydra.Sources.Kernel.Terms.Schemas - Hydra.Sources.Kernel.Terms.Serialization - Hydra.Sources.Kernel.Terms.Show.Core - Hydra.Sources.Kernel.Terms.Show.Error.Core - Hydra.Sources.Kernel.Terms.Show.Errors - Hydra.Sources.Kernel.Terms.Show.Graph - Hydra.Sources.Kernel.Terms.Show.Meta - Hydra.Sources.Kernel.Terms.Show.Paths - Hydra.Sources.Kernel.Terms.Show.Typing - Hydra.Sources.Kernel.Terms.Show.Util - Hydra.Sources.Kernel.Terms.Sorting - Hydra.Sources.Kernel.Terms.Substitution - Hydra.Sources.Kernel.Terms.Templates - Hydra.Sources.Kernel.Terms.Unification - Hydra.Sources.Kernel.Terms.Validate.Core - Hydra.Sources.Kernel.Terms.Validate.Packaging - Hydra.Sources.Kernel.Types.All - Hydra.Sources.Kernel.Types.Ast - Hydra.Sources.Kernel.Types.Classes - Hydra.Sources.Kernel.Types.Coders - Hydra.Sources.Kernel.Types.Context - Hydra.Sources.Kernel.Types.Core - Hydra.Sources.Kernel.Types.Error.Checking - Hydra.Sources.Kernel.Types.Error.Core - Hydra.Sources.Kernel.Types.Error.Packaging - Hydra.Sources.Kernel.Types.Errors - Hydra.Sources.Kernel.Types.Graph - Hydra.Sources.Kernel.Types.Module - Hydra.Sources.Kernel.Types.Packaging - Hydra.Sources.Kernel.Types.Parsing - Hydra.Sources.Kernel.Types.Paths - Hydra.Sources.Kernel.Types.Phantoms - Hydra.Sources.Kernel.Types.Query - Hydra.Sources.Kernel.Types.Relational - Hydra.Sources.Kernel.Types.Tabular - Hydra.Sources.Kernel.Types.Testing - Hydra.Sources.Kernel.Types.Topology - Hydra.Sources.Kernel.Types.Typing - Hydra.Sources.Kernel.Types.Util - Hydra.Sources.Kernel.Types.Variants - Hydra.Sources.Libraries - Hydra.Sources.Test.All - Hydra.Sources.Test.Annotations - Hydra.Sources.Test.Checking.Advanced - Hydra.Sources.Test.Checking.AlgebraicTypes - Hydra.Sources.Test.Checking.All - Hydra.Sources.Test.Checking.Collections - Hydra.Sources.Test.Checking.Failures - Hydra.Sources.Test.Checking.Fundamentals - Hydra.Sources.Test.Checking.NominalTypes - Hydra.Sources.Test.EtaExpansion - Hydra.Sources.Test.Formatting - Hydra.Sources.Test.Hoisting.All - Hydra.Sources.Test.Hoisting.Cases - Hydra.Sources.Test.Hoisting.Let - Hydra.Sources.Test.Inference.AlgebraicTypes - Hydra.Sources.Test.Inference.AlgorithmW - Hydra.Sources.Test.Inference.All - Hydra.Sources.Test.Inference.Classes - Hydra.Sources.Test.Inference.Failures - Hydra.Sources.Test.Inference.Fundamentals - Hydra.Sources.Test.Inference.KernelExamples - Hydra.Sources.Test.Inference.NominalTypes - Hydra.Sources.Test.Json.Parser - Hydra.Sources.Test.Json.Roundtrip - Hydra.Sources.Test.Json.Writer - Hydra.Sources.Test.Lib.Chars - Hydra.Sources.Test.Lib.Eithers - Hydra.Sources.Test.Lib.Equality - Hydra.Sources.Test.Lib.Lists - Hydra.Sources.Test.Lib.Literals - Hydra.Sources.Test.Lib.Logic - Hydra.Sources.Test.Lib.Maps - Hydra.Sources.Test.Lib.Math - Hydra.Sources.Test.Lib.Maybes - Hydra.Sources.Test.Lib.Pairs - Hydra.Sources.Test.Lib.Regex - Hydra.Sources.Test.Lib.Sets - Hydra.Sources.Test.Lib.Strings - Hydra.Sources.Test.Ordering - Hydra.Sources.Test.Reduction - Hydra.Sources.Test.Rewriting - Hydra.Sources.Test.Serialization - Hydra.Sources.Test.Sorting - Hydra.Sources.Test.Substitution - Hydra.Sources.Test.TestGraph - Hydra.Sources.Test.TestSuite - Hydra.Sources.Test.TestTerms - Hydra.Sources.Test.TestTypes - Hydra.Sources.Test.Transform - Hydra.Sources.Test.Unification - Hydra.Sources.Test.Utils - Hydra.Sources.Test.Validate.All - Hydra.Sources.Test.Validate.Core - Hydra.Sources.Yaml.Model - Hydra.Tools.Bytestrings - Hydra.Tools.Debug - Org.Example.Lispy - Hydra.Adapt - Hydra.Annotations - Hydra.Arity - Hydra.Ast - Hydra.Checking - Hydra.Classes - Hydra.CodeGeneration - Hydra.Coders - Hydra.CoderUtils - Hydra.Constants - Hydra.Context - Hydra.Core - Hydra.Decode.Ast - Hydra.Decode.Classes - Hydra.Decode.Coders - Hydra.Decode.Context - Hydra.Decode.Core - Hydra.Decode.Error.Checking - Hydra.Decode.Error.Core - Hydra.Decode.Errors - Hydra.Decode.Json - Hydra.Decode.Json.Model - Hydra.Decode.Module - Hydra.Decode.Parsing - Hydra.Decode.Paths - Hydra.Decode.Phantoms - Hydra.Decode.Query - Hydra.Decode.Relational - Hydra.Decode.Tabular - Hydra.Decode.Testing - Hydra.Decode.Topology - Hydra.Decode.Typing - Hydra.Decode.Util - Hydra.Decode.Variants - Hydra.Decoding - Hydra.Dsl.Ast - Hydra.Dsl.Classes - Hydra.Dsl.Coders - Hydra.Dsl.Context - Hydra.Dsl.Core - Hydra.Dsl.Error.Checking - Hydra.Dsl.Error.Core - Hydra.Dsl.Error.Packaging - Hydra.Dsl.Errors - Hydra.Dsl.Ext.Haskell.Syntax - Hydra.Dsl.Ext.Org.Yaml.Model - Hydra.Dsl.Graph - Hydra.Dsl.Json.Model - Hydra.Dsl.Module - Hydra.Dsl.Packaging - Hydra.Dsl.Parsing - Hydra.Dsl.Paths - Hydra.Dsl.Query - Hydra.Dsl.Relational - Hydra.Dsl.Tabular - Hydra.Dsl.Testing - Hydra.Dsl.Topology - Hydra.Dsl.Typing - Hydra.Dsl.Util - Hydra.Dsl.Variants - Hydra.Dsls - Hydra.Encode.Ast - Hydra.Encode.Classes - Hydra.Encode.Coders - Hydra.Encode.Context - Hydra.Encode.Core - Hydra.Encode.Error.Checking - Hydra.Encode.Error.Core - Hydra.Encode.Errors - Hydra.Encode.Json - Hydra.Encode.Json.Model - Hydra.Encode.Module - Hydra.Encode.Parsing - Hydra.Encode.Paths - Hydra.Encode.Phantoms - Hydra.Encode.Query - Hydra.Encode.Relational - Hydra.Encode.Tabular - Hydra.Encode.Testing - Hydra.Encode.Topology - Hydra.Encode.Typing - Hydra.Encode.Util - Hydra.Encode.Variants - Hydra.Encoding - Hydra.Error.Checking - Hydra.Error.Core - Hydra.Error.Packaging - Hydra.Errors - Hydra.Eval.Lib.Eithers - Hydra.Eval.Lib.Equality - Hydra.Eval.Lib.Lists - Hydra.Eval.Lib.Logic - Hydra.Eval.Lib.Maps - Hydra.Eval.Lib.Math - Hydra.Eval.Lib.Maybes - Hydra.Eval.Lib.Pairs - Hydra.Eval.Lib.Sets - Hydra.Ext.Haskell.Coder - Hydra.Ext.Haskell.Language - Hydra.Ext.Haskell.Operators - Hydra.Ext.Haskell.Serde - Hydra.Ext.Haskell.Syntax - Hydra.Ext.Haskell.Testing - Hydra.Ext.Haskell.Utils - Hydra.Ext.Org.Json.Decoding - Hydra.Ext.Org.Yaml.Model - Hydra.Extract.Core - Hydra.Extract.Helpers - Hydra.Extract.Json - Hydra.Extract.Util - Hydra.Formatting - Hydra.Graph - Hydra.Hoisting - Hydra.Inference - Hydra.Json.Bootstrap - Hydra.Json.Decode - Hydra.Json.Encode - Hydra.Json.Model - Hydra.Json.Parser - Hydra.Json.Writer - Hydra.Json.Yaml.Decode - Hydra.Json.Yaml.Encode - Hydra.Languages - Hydra.Lexical - Hydra.Lib.Names - Hydra.Literals - Hydra.Module - Hydra.Names - Hydra.Packaging - Hydra.Parsers - Hydra.Parsing - Hydra.Paths - Hydra.Phantoms - Hydra.Query - Hydra.Reduction - Hydra.Reflect - Hydra.Relational - Hydra.Rewriting - Hydra.Schemas - Hydra.Serialization - Hydra.Show.Core - Hydra.Show.Error.Core - Hydra.Show.Errors - Hydra.Show.Graph - Hydra.Show.Meta - Hydra.Show.Paths - Hydra.Show.Typing - Hydra.Show.Util - Hydra.Sorting - Hydra.Sources.Decode.Ast - Hydra.Sources.Decode.Classes - Hydra.Sources.Decode.Coders - Hydra.Sources.Decode.Context - Hydra.Sources.Decode.Core - Hydra.Sources.Decode.Error.Checking - Hydra.Sources.Decode.Error.Core - Hydra.Sources.Decode.Error.Packaging - Hydra.Sources.Decode.Errors - Hydra.Sources.Decode.Json.Model - Hydra.Sources.Decode.Module - Hydra.Sources.Decode.Packaging - Hydra.Sources.Decode.Parsing - Hydra.Sources.Decode.Paths - Hydra.Sources.Decode.Phantoms - Hydra.Sources.Decode.Query - Hydra.Sources.Decode.Relational - Hydra.Sources.Decode.Tabular - Hydra.Sources.Decode.Testing - Hydra.Sources.Decode.Topology - Hydra.Sources.Decode.Typing - Hydra.Sources.Decode.Util - Hydra.Sources.Decode.Variants - Hydra.Sources.Encode.Ast - Hydra.Sources.Encode.Classes - Hydra.Sources.Encode.Coders - Hydra.Sources.Encode.Context - Hydra.Sources.Encode.Core - Hydra.Sources.Encode.Error.Checking - Hydra.Sources.Encode.Error.Core - Hydra.Sources.Encode.Error.Packaging - Hydra.Sources.Encode.Errors - Hydra.Sources.Encode.Json.Model - Hydra.Sources.Encode.Module - Hydra.Sources.Encode.Packaging - Hydra.Sources.Encode.Parsing - Hydra.Sources.Encode.Paths - Hydra.Sources.Encode.Phantoms - Hydra.Sources.Encode.Query - Hydra.Sources.Encode.Relational - Hydra.Sources.Encode.Tabular - Hydra.Sources.Encode.Testing - Hydra.Sources.Encode.Topology - Hydra.Sources.Encode.Typing - Hydra.Sources.Encode.Util - Hydra.Sources.Encode.Variants - Hydra.Substitution - Hydra.Tabular - Hydra.Templates - Hydra.Test.Transform - Hydra.Test.Utils - Hydra.Testing - Hydra.Topology - Hydra.Typing - Hydra.Unification - Hydra.Util - Hydra.Validate.Core - Hydra.Validate.Packaging - Hydra.Variants - other-modules: - Paths_hydra - hs-source-dirs: - src/main/haskell - src/gen-main/haskell - build-depends: - aeson >=2.1.0 && <2.3 - , base >=4.19.0 && <4.22 - , base64-bytestring >=1.2.1 && <1.3 - , bytestring >=0.11.5 && <0.13 - , containers >=0.6.7 && <0.8 - , directory >=1.3.6 && <1.4 - , filepath >=1.4.200 && <1.6 - , regex-tdfa >=1.3.2 && <1.4 - , scientific >=0.3.7 && <0.4 - , split >=0.2.3 && <0.3 - , text >=2.0.2 && <2.2 - , vector >=0.12.0 && <0.14 - default-language: Haskell2010 - -executable update-generation-tests - main-is: Main.hs - other-modules: - Generation.Hydra.Test.AnnotationsSpec - Generation.Hydra.Test.FormattingSpec - Generation.Hydra.Test.Lib.CharsSpec - Generation.Hydra.Test.Lib.EithersSpec - Generation.Hydra.Test.Lib.EqualitySpec - Generation.Hydra.Test.Lib.ListsSpec - Generation.Hydra.Test.Lib.LiteralsSpec - Generation.Hydra.Test.Lib.LogicSpec - Generation.Hydra.Test.Lib.MapsSpec - Generation.Hydra.Test.Lib.MathSpec - Generation.Hydra.Test.Lib.MaybesSpec - Generation.Hydra.Test.Lib.PairsSpec - Generation.Hydra.Test.Lib.RegexSpec - Generation.Hydra.Test.Lib.SetsSpec - Generation.Hydra.Test.Lib.StringsSpec - Generation.Hydra.Test.ReductionSpec - Generation.Hydra.Test.SortingSpec - Generation.Spec - Hydra.Test.Annotations - Hydra.Test.Checking.Advanced - Hydra.Test.Checking.AlgebraicTypes - Hydra.Test.Checking.All - Hydra.Test.Checking.Collections - Hydra.Test.Checking.Failures - Hydra.Test.Checking.Fundamentals - Hydra.Test.Checking.NominalTypes - Hydra.Test.EtaExpansion - Hydra.Test.Formatting - Hydra.Test.Hoisting.All - Hydra.Test.Hoisting.Cases - Hydra.Test.Hoisting.Let - Hydra.Test.Inference.AlgebraicTypes - Hydra.Test.Inference.AlgorithmW - Hydra.Test.Inference.All - Hydra.Test.Inference.Classes - Hydra.Test.Inference.Failures - Hydra.Test.Inference.Fundamentals - Hydra.Test.Inference.KernelExamples - Hydra.Test.Inference.NominalTypes - Hydra.Test.Json.Parser - Hydra.Test.Json.Roundtrip - Hydra.Test.Json.Writer - Hydra.Test.Lib.Chars - Hydra.Test.Lib.Eithers - Hydra.Test.Lib.Equality - Hydra.Test.Lib.Lists - Hydra.Test.Lib.Literals - Hydra.Test.Lib.Logic - Hydra.Test.Lib.Maps - Hydra.Test.Lib.Math - Hydra.Test.Lib.Maybes - Hydra.Test.Lib.Pairs - Hydra.Test.Lib.Regex - Hydra.Test.Lib.Sets - Hydra.Test.Lib.Strings - Hydra.Test.Ordering - Hydra.Test.Reduction - Hydra.Test.Rewriting - Hydra.Test.Serialization - Hydra.Test.Sorting - Hydra.Test.Substitution - Hydra.Test.TestGraph - Hydra.Test.TestSuite - Hydra.Test.TestTerms - Hydra.Test.TestTypes - Hydra.Test.Unification - Hydra.Test.Validate.All - Hydra.Test.Validate.Core - Paths_hydra - hs-source-dirs: - src/exec/update-generation-tests - src/gen-test/haskell - ghc-options: -rtsopts - build-depends: - aeson >=2.1.0 && <2.3 - , base >=4.19.0 && <4.22 - , base64-bytestring >=1.2.1 && <1.3 - , bytestring >=0.11.5 && <0.13 - , containers >=0.6.7 && <0.8 - , directory >=1.3.6 && <1.4 - , filepath >=1.4.200 && <1.6 - , hspec >=2.11.0 && <2.12 - , hydra - , regex-tdfa >=1.3.2 && <1.4 - , scientific >=0.3.7 && <0.4 - , split >=0.2.3 && <0.3 - , text >=2.0.2 && <2.2 - , vector >=0.12.0 && <0.14 - default-language: Haskell2010 - -executable update-haskell-eval-lib - main-is: Main.hs - other-modules: - Paths_hydra - hs-source-dirs: - src/exec/update-haskell-eval-lib - ghc-options: -rtsopts - build-depends: - aeson >=2.1.0 && <2.3 - , base >=4.19.0 && <4.22 - , base64-bytestring >=1.2.1 && <1.3 - , bytestring >=0.11.5 && <0.13 - , containers >=0.6.7 && <0.8 - , directory >=1.3.6 && <1.4 - , filepath >=1.4.200 && <1.6 - , hydra - , regex-tdfa >=1.3.2 && <1.4 - , scientific >=0.3.7 && <0.4 - , split >=0.2.3 && <0.3 - , text >=2.0.2 && <2.2 - , vector >=0.12.0 && <0.14 - default-language: Haskell2010 - -executable update-haskell-kernel - main-is: Main.hs - other-modules: - Paths_hydra - hs-source-dirs: - src/exec/update-haskell-kernel - ghc-options: -rtsopts - build-depends: - aeson >=2.1.0 && <2.3 - , base >=4.19.0 && <4.22 - , base64-bytestring >=1.2.1 && <1.3 - , bytestring >=0.11.5 && <0.13 - , containers >=0.6.7 && <0.8 - , directory >=1.3.6 && <1.4 - , filepath >=1.4.200 && <1.6 - , hydra - , regex-tdfa >=1.3.2 && <1.4 - , scientific >=0.3.7 && <0.4 - , split >=0.2.3 && <0.3 - , text >=2.0.2 && <2.2 - , vector >=0.12.0 && <0.14 - default-language: Haskell2010 - -executable update-haskell-sources - main-is: Main.hs - other-modules: - Paths_hydra - hs-source-dirs: - src/exec/update-haskell-sources - ghc-options: -rtsopts - build-depends: - aeson >=2.1.0 && <2.3 - , base >=4.19.0 && <4.22 - , base64-bytestring >=1.2.1 && <1.3 - , bytestring >=0.11.5 && <0.13 - , containers >=0.6.7 && <0.8 - , directory >=1.3.6 && <1.4 - , filepath >=1.4.200 && <1.6 - , hydra - , regex-tdfa >=1.3.2 && <1.4 - , scientific >=0.3.7 && <0.4 - , split >=0.2.3 && <0.3 - , text >=2.0.2 && <2.2 - , vector >=0.12.0 && <0.14 - default-language: Haskell2010 - -executable update-json-kernel - main-is: Main.hs - other-modules: - Paths_hydra - hs-source-dirs: - src/exec/update-json-kernel - ghc-options: -rtsopts - build-depends: - aeson >=2.1.0 && <2.3 - , base >=4.19.0 && <4.22 - , base64-bytestring >=1.2.1 && <1.3 - , bytestring >=0.11.5 && <0.13 - , containers >=0.6.7 && <0.8 - , directory >=1.3.6 && <1.4 - , filepath >=1.4.200 && <1.6 - , hydra - , regex-tdfa >=1.3.2 && <1.4 - , scientific >=0.3.7 && <0.4 - , split >=0.2.3 && <0.3 - , text >=2.0.2 && <2.2 - , vector >=0.12.0 && <0.14 - default-language: Haskell2010 - -executable update-json-main - main-is: Main.hs - other-modules: - Paths_hydra - hs-source-dirs: - src/exec/update-json-main - ghc-options: -rtsopts - build-depends: - aeson >=2.1.0 && <2.3 - , base >=4.19.0 && <4.22 - , base64-bytestring >=1.2.1 && <1.3 - , bytestring >=0.11.5 && <0.13 - , containers >=0.6.7 && <0.8 - , directory >=1.3.6 && <1.4 - , filepath >=1.4.200 && <1.6 - , hydra - , regex-tdfa >=1.3.2 && <1.4 - , scientific >=0.3.7 && <0.4 - , split >=0.2.3 && <0.3 - , text >=2.0.2 && <2.2 - , vector >=0.12.0 && <0.14 - default-language: Haskell2010 - -executable update-json-manifest - main-is: Main.hs - other-modules: - Paths_hydra - hs-source-dirs: - src/exec/update-json-manifest - ghc-options: -rtsopts - build-depends: - aeson >=2.1.0 && <2.3 - , base >=4.19.0 && <4.22 - , base64-bytestring >=1.2.1 && <1.3 - , bytestring >=0.11.5 && <0.13 - , containers >=0.6.7 && <0.8 - , directory >=1.3.6 && <1.4 - , filepath >=1.4.200 && <1.6 - , hydra - , regex-tdfa >=1.3.2 && <1.4 - , scientific >=0.3.7 && <0.4 - , split >=0.2.3 && <0.3 - , text >=2.0.2 && <2.2 - , vector >=0.12.0 && <0.14 - default-language: Haskell2010 - -executable update-json-test - main-is: Main.hs - other-modules: - Paths_hydra - hs-source-dirs: - src/exec/update-json-test - ghc-options: -rtsopts - build-depends: - aeson >=2.1.0 && <2.3 - , base >=4.19.0 && <4.22 - , base64-bytestring >=1.2.1 && <1.3 - , bytestring >=0.11.5 && <0.13 - , containers >=0.6.7 && <0.8 - , directory >=1.3.6 && <1.4 - , filepath >=1.4.200 && <1.6 - , hydra - , regex-tdfa >=1.3.2 && <1.4 - , scientific >=0.3.7 && <0.4 - , split >=0.2.3 && <0.3 - , text >=2.0.2 && <2.2 - , vector >=0.12.0 && <0.14 - default-language: Haskell2010 - -executable update-kernel-tests - main-is: Main.hs - other-modules: - Generation.Hydra.Test.AnnotationsSpec - Generation.Hydra.Test.FormattingSpec - Generation.Hydra.Test.Lib.CharsSpec - Generation.Hydra.Test.Lib.EithersSpec - Generation.Hydra.Test.Lib.EqualitySpec - Generation.Hydra.Test.Lib.ListsSpec - Generation.Hydra.Test.Lib.LiteralsSpec - Generation.Hydra.Test.Lib.LogicSpec - Generation.Hydra.Test.Lib.MapsSpec - Generation.Hydra.Test.Lib.MathSpec - Generation.Hydra.Test.Lib.MaybesSpec - Generation.Hydra.Test.Lib.PairsSpec - Generation.Hydra.Test.Lib.RegexSpec - Generation.Hydra.Test.Lib.SetsSpec - Generation.Hydra.Test.Lib.StringsSpec - Generation.Hydra.Test.ReductionSpec - Generation.Hydra.Test.SortingSpec - Generation.Spec - Hydra.Test.Annotations - Hydra.Test.Checking.Advanced - Hydra.Test.Checking.AlgebraicTypes - Hydra.Test.Checking.All - Hydra.Test.Checking.Collections - Hydra.Test.Checking.Failures - Hydra.Test.Checking.Fundamentals - Hydra.Test.Checking.NominalTypes - Hydra.Test.EtaExpansion - Hydra.Test.Formatting - Hydra.Test.Hoisting.All - Hydra.Test.Hoisting.Cases - Hydra.Test.Hoisting.Let - Hydra.Test.Inference.AlgebraicTypes - Hydra.Test.Inference.AlgorithmW - Hydra.Test.Inference.All - Hydra.Test.Inference.Classes - Hydra.Test.Inference.Failures - Hydra.Test.Inference.Fundamentals - Hydra.Test.Inference.KernelExamples - Hydra.Test.Inference.NominalTypes - Hydra.Test.Json.Parser - Hydra.Test.Json.Roundtrip - Hydra.Test.Json.Writer - Hydra.Test.Lib.Chars - Hydra.Test.Lib.Eithers - Hydra.Test.Lib.Equality - Hydra.Test.Lib.Lists - Hydra.Test.Lib.Literals - Hydra.Test.Lib.Logic - Hydra.Test.Lib.Maps - Hydra.Test.Lib.Math - Hydra.Test.Lib.Maybes - Hydra.Test.Lib.Pairs - Hydra.Test.Lib.Regex - Hydra.Test.Lib.Sets - Hydra.Test.Lib.Strings - Hydra.Test.Ordering - Hydra.Test.Reduction - Hydra.Test.Rewriting - Hydra.Test.Serialization - Hydra.Test.Sorting - Hydra.Test.Substitution - Hydra.Test.TestGraph - Hydra.Test.TestSuite - Hydra.Test.TestTerms - Hydra.Test.TestTypes - Hydra.Test.Unification - Hydra.Test.Validate.All - Hydra.Test.Validate.Core - Paths_hydra - hs-source-dirs: - src/exec/update-kernel-tests - src/gen-test/haskell - ghc-options: -rtsopts - build-depends: - aeson >=2.1.0 && <2.3 - , base >=4.19.0 && <4.22 - , base64-bytestring >=1.2.1 && <1.3 - , bytestring >=0.11.5 && <0.13 - , containers >=0.6.7 && <0.8 - , directory >=1.3.6 && <1.4 - , filepath >=1.4.200 && <1.6 - , hspec >=2.11.0 && <2.12 - , hydra - , regex-tdfa >=1.3.2 && <1.4 - , scientific >=0.3.7 && <0.4 - , split >=0.2.3 && <0.3 - , text >=2.0.2 && <2.2 - , vector >=0.12.0 && <0.14 - default-language: Haskell2010 - -executable verify-json-kernel - main-is: Main.hs - other-modules: - Paths_hydra - hs-source-dirs: - src/exec/verify-json-kernel - ghc-options: -rtsopts - build-depends: - aeson >=2.1.0 && <2.3 - , base >=4.19.0 && <4.22 - , base64-bytestring >=1.2.1 && <1.3 - , bytestring >=0.11.5 && <0.13 - , containers >=0.6.7 && <0.8 - , directory >=1.3.6 && <1.4 - , filepath >=1.4.200 && <1.6 - , hydra - , regex-tdfa >=1.3.2 && <1.4 - , scientific >=0.3.7 && <0.4 - , split >=0.2.3 && <0.3 - , text >=2.0.2 && <2.2 - , vector >=0.12.0 && <0.14 - default-language: Haskell2010 - -test-suite hydra-test - type: exitcode-stdio-1.0 - main-is: Spec.hs - other-modules: - GenerationSpec - Hydra.ArbitraryCore - Hydra.CoreCodersSpec - Hydra.Dsl.TypesSpec - Hydra.EvalPrimitives - Hydra.Reference.AlgorithmW - Hydra.Reference.AlgorithmWBridge - Hydra.Reference.AlgorithmWSpec - Hydra.TestData - Hydra.TestSuiteSpec - Hydra.TestUtils - Hydra.UpdateGenerationTests - Generation.Hydra.Test.AnnotationsSpec - Generation.Hydra.Test.FormattingSpec - Generation.Hydra.Test.Lib.CharsSpec - Generation.Hydra.Test.Lib.EithersSpec - Generation.Hydra.Test.Lib.EqualitySpec - Generation.Hydra.Test.Lib.ListsSpec - Generation.Hydra.Test.Lib.LiteralsSpec - Generation.Hydra.Test.Lib.LogicSpec - Generation.Hydra.Test.Lib.MapsSpec - Generation.Hydra.Test.Lib.MathSpec - Generation.Hydra.Test.Lib.MaybesSpec - Generation.Hydra.Test.Lib.PairsSpec - Generation.Hydra.Test.Lib.RegexSpec - Generation.Hydra.Test.Lib.SetsSpec - Generation.Hydra.Test.Lib.StringsSpec - Generation.Hydra.Test.ReductionSpec - Generation.Hydra.Test.SortingSpec - Generation.Spec - Hydra.Test.Annotations - Hydra.Test.Checking.Advanced - Hydra.Test.Checking.AlgebraicTypes - Hydra.Test.Checking.All - Hydra.Test.Checking.Collections - Hydra.Test.Checking.Failures - Hydra.Test.Checking.Fundamentals - Hydra.Test.Checking.NominalTypes - Hydra.Test.EtaExpansion - Hydra.Test.Formatting - Hydra.Test.Hoisting.All - Hydra.Test.Hoisting.Cases - Hydra.Test.Hoisting.Let - Hydra.Test.Inference.AlgebraicTypes - Hydra.Test.Inference.AlgorithmW - Hydra.Test.Inference.All - Hydra.Test.Inference.Classes - Hydra.Test.Inference.Failures - Hydra.Test.Inference.Fundamentals - Hydra.Test.Inference.KernelExamples - Hydra.Test.Inference.NominalTypes - Hydra.Test.Json.Parser - Hydra.Test.Json.Roundtrip - Hydra.Test.Json.Writer - Hydra.Test.Lib.Chars - Hydra.Test.Lib.Eithers - Hydra.Test.Lib.Equality - Hydra.Test.Lib.Lists - Hydra.Test.Lib.Literals - Hydra.Test.Lib.Logic - Hydra.Test.Lib.Maps - Hydra.Test.Lib.Math - Hydra.Test.Lib.Maybes - Hydra.Test.Lib.Pairs - Hydra.Test.Lib.Regex - Hydra.Test.Lib.Sets - Hydra.Test.Lib.Strings - Hydra.Test.Ordering - Hydra.Test.Reduction - Hydra.Test.Rewriting - Hydra.Test.Serialization - Hydra.Test.Sorting - Hydra.Test.Substitution - Hydra.Test.TestGraph - Hydra.Test.TestSuite - Hydra.Test.TestTerms - Hydra.Test.TestTypes - Hydra.Test.Unification - Hydra.Test.Validate.All - Hydra.Test.Validate.Core - Paths_hydra - hs-source-dirs: - src/test/haskell - src/gen-test/haskell - build-depends: - HUnit - , QuickCheck +version: 0.15.0 +synopsis: The Hydra Haskell head: primitives, DSL infrastructure, generation driver +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". The Haskell head provides the hand-written Haskell runtime Hydra needs in order to build and regenerate itself: primitive libraries (Hydra.Lib.*), the embedded DSL infrastructure (Hydra.Dsl.*), the generation driver (Hydra.Generation), the kernel entry point (Hydra.Kernel), module support utilities, and the exec binaries that drive Hydra's Haskell code generation. It consumes the language-independent kernel DSL sources and generated kernel runtime from packages/hydra-kernel/, plus the Haskell coder DSL sources and generated output from packages/hydra-haskell/, and produces all Haskell-host build artifacts. +category: Data +homepage: https://github.com/CategoricalData/hydra#readme +bug-reports: https://github.com/CategoricalData/hydra/issues +author: Joshua Shinavier +maintainer: Joshua Shinavier +license: Apache-2.0 +license-file: LICENSE +build-type: Simple +extra-source-files: + LICENSE + +source-repository head + type: git + location: https://github.com/CategoricalData/hydra + +library + exposed-modules: + Com.Gdblab.PathAlgebra.Expressions + Com.Gdblab.PathAlgebra.Syntax + Hydra.Adapt + Hydra.Analysis + Hydra.Annotations + Hydra.Arity + Hydra.Ast + Hydra.Atlas + Hydra.Avro.Coder + Hydra.Avro.Encoder + Hydra.Avro.Environment + Hydra.Avro.Language + Hydra.Avro.Schema + Hydra.Avro.SchemaJson + Hydra.Avro.Testing + Hydra.Azure.Dtld + Hydra.Checking + Hydra.Classes + Hydra.Codegen + Hydra.Coders + Hydra.Constants + Hydra.Context + Hydra.Coq.Coder + Hydra.Coq.Environment + Hydra.Coq.Generate + Hydra.Coq.GenerateDriver + Hydra.Coq.Language + Hydra.Coq.Serde + Hydra.Coq.Syntax + Hydra.Coq.Utils + Hydra.Core + Hydra.Cpp.Coder + Hydra.Cpp.Environment + Hydra.Cpp.Language + Hydra.Cpp.Names + Hydra.Cpp.Serde + Hydra.Cpp.Syntax + Hydra.Cpp.Utils + Hydra.Csharp.Language + Hydra.Csharp.Syntax + Hydra.Cypher.Features + Hydra.Cypher.OpenCypher + Hydra.Datalog.Syntax + Hydra.Decode.Ast + Hydra.Decode.Classes + Hydra.Decode.Coders + Hydra.Decode.Context + Hydra.Decode.Core + Hydra.Decode.Error.Checking + Hydra.Decode.Error.Core + Hydra.Decode.Errors + Hydra.Decode.Json.Model + Hydra.Decode.Packaging + Hydra.Decode.Parsing + Hydra.Decode.Paths + Hydra.Decode.Pg.Mapping + Hydra.Decode.Pg.Model + Hydra.Decode.Phantoms + Hydra.Decode.Query + Hydra.Decode.Relational + Hydra.Decode.Tabular + Hydra.Decode.Testing + Hydra.Decode.Topology + Hydra.Decode.Typing + Hydra.Decode.Util + Hydra.Decode.Variants + Hydra.Decoding + Hydra.Delta.Parquet + Hydra.Demos.AvroBicoder + Hydra.Demos.AvroToPropertyGraphs + Hydra.Demos.Genpg.Demo + Hydra.Demos.Genpg.ExampleDatabaseSchema + Hydra.Demos.Genpg.ExampleGraphSchema + Hydra.Demos.Genpg.ExampleMapping + Hydra.Demos.Genpg.Examples.Health.DatabaseSchema + Hydra.Demos.Genpg.Examples.Health.GraphSchema + Hydra.Demos.Genpg.Examples.Health.Mapping + Hydra.Demos.Genpg.Examples.Sales.DatabaseSchema + Hydra.Demos.Genpg.Examples.Sales.GraphSchema + Hydra.Demos.Genpg.Examples.Sales.Mapping + Hydra.Demos.Genpg.GenerateJava + Hydra.Demos.Genpg.GeneratePython + Hydra.Demos.Genpg.Modules + Hydra.Demos.Genpg.Rdf + Hydra.Demos.Genpg.Runtime + Hydra.Demos.Genpg.Transform + Hydra.Demos.Grad.Demo + Hydra.Demos.GraphqlJson + Hydra.Demos.MeteredEvaluation + Hydra.Demos.Shacl.Demo + Hydra.Demos.Shacl.ShaclRdf + Hydra.Demos.ValidatePg.Demo + Hydra.Dependencies + Hydra.Differentiation + Hydra.Digest + Hydra.Dsl.Annotations + Hydra.Dsl.Ast + Hydra.Dsl.AsTerm + Hydra.Dsl.AsType + Hydra.Dsl.Atlas + Hydra.Dsl.Avro.Environment + Hydra.Dsl.Avro.Schema + Hydra.Dsl.Avro.Testing + Hydra.Dsl.Azure.Dtld + Hydra.Dsl.Bootstrap + Hydra.Dsl.Classes + Hydra.Dsl.Coders + Hydra.Dsl.Com.Gdblab.PathAlgebra.Expressions + Hydra.Dsl.Com.Gdblab.PathAlgebra.Syntax + Hydra.Dsl.Context + Hydra.Dsl.Coq.Environment + Hydra.Dsl.Coq.Syntax + Hydra.Dsl.Core + Hydra.Dsl.Cpp.Environment + Hydra.Dsl.Cpp.Syntax + Hydra.Dsl.Csharp.Syntax + Hydra.Dsl.Cypher.Features + Hydra.Dsl.Cypher.OpenCypher + Hydra.Dsl.Datalog.Syntax + Hydra.Dsl.Deep.Lib.Math + Hydra.Dsl.Delta.Parquet + Hydra.Dsl.Error.Checking + Hydra.Dsl.Error.Core + Hydra.Dsl.Error.Packaging + Hydra.Dsl.Error.Pg + Hydra.Dsl.Errors + Hydra.Dsl.Geojson.Model + Hydra.Dsl.Go.Syntax + Hydra.Dsl.Graph + Hydra.Dsl.Graphql.Syntax + Hydra.Dsl.Graphviz.Dot + Hydra.Dsl.Haskell.Environment + Hydra.Dsl.Haskell.Syntax + Hydra.Dsl.Iana.Linkrelations + Hydra.Dsl.Java.Environment + Hydra.Dsl.Java.Helpers + Hydra.Dsl.Java.Syntax + Hydra.Dsl.JavaScript.Helpers + Hydra.Dsl.JavaScript.Syntax + Hydra.Dsl.Json.Model + Hydra.Dsl.Json.Schema + Hydra.Dsl.Kusto.Kql + Hydra.Dsl.Lisp.Syntax + Hydra.Dsl.Literals + Hydra.Dsl.LiteralTypes + Hydra.Dsl.Meta.Base + Hydra.Dsl.Meta.Common + Hydra.Dsl.Meta.Context + Hydra.Dsl.Meta.Core + Hydra.Dsl.Meta.DeepCore + Hydra.Dsl.Meta.Graph + Hydra.Dsl.Meta.Lib.Chars + Hydra.Dsl.Meta.Lib.Eithers + Hydra.Dsl.Meta.Lib.Equality + Hydra.Dsl.Meta.Lib.Lists + Hydra.Dsl.Meta.Lib.Literals + Hydra.Dsl.Meta.Lib.Logic + Hydra.Dsl.Meta.Lib.Maps + Hydra.Dsl.Meta.Lib.Math + Hydra.Dsl.Meta.Lib.Maybes + Hydra.Dsl.Meta.Lib.Pairs + Hydra.Dsl.Meta.Lib.Regex + Hydra.Dsl.Meta.Lib.Sets + Hydra.Dsl.Meta.Lib.Strings + Hydra.Dsl.Meta.Literals + Hydra.Dsl.Meta.Phantoms + Hydra.Dsl.Meta.Tabular + Hydra.Dsl.Meta.Terms + Hydra.Dsl.Meta.Testing + Hydra.Dsl.Meta.Types + Hydra.Dsl.Meta.Variants + Hydra.Dsl.OpenGql.Grammar + Hydra.Dsl.Osv.Schema + Hydra.Dsl.Owl.Syntax + Hydra.Dsl.Packaging + Hydra.Dsl.Parquet.Format + Hydra.Dsl.Parsing + Hydra.Dsl.Paths + Hydra.Dsl.Pegasus.Pdl + Hydra.Dsl.Pg.Graphson.Syntax + Hydra.Dsl.Pg.Mapping + Hydra.Dsl.Pg.Mappings + Hydra.Dsl.Pg.Model + Hydra.Dsl.Pg.Query + Hydra.Dsl.Pg.Rdf.Environment + Hydra.Dsl.Pg.Schemas + Hydra.Dsl.Prims + Hydra.Dsl.Protobuf.Any + Hydra.Dsl.Protobuf.Environment + Hydra.Dsl.Protobuf.Proto3 + Hydra.Dsl.Protobuf.SourceContext + Hydra.Dsl.Python.Environment + Hydra.Dsl.Python.Helpers + Hydra.Dsl.Python.Syntax + Hydra.Dsl.Query + Hydra.Dsl.Rdf.Syntax + Hydra.Dsl.Relational + Hydra.Dsl.Rust.Syntax + Hydra.Dsl.Scala.Syntax + Hydra.Dsl.Shacl.Model + Hydra.Dsl.Shex.Syntax + Hydra.Dsl.Sql.Syntax + Hydra.Dsl.Stac.Items + Hydra.Dsl.Tabular + Hydra.Dsl.Terms + Hydra.Dsl.Testing + Hydra.Dsl.Tests + Hydra.Dsl.Tinkerpop.Features + Hydra.Dsl.Tinkerpop.Gremlin + Hydra.Dsl.Topology + Hydra.Dsl.Types + Hydra.Dsl.TypeScript.Model + Hydra.Dsl.Typing + Hydra.Dsl.Util + Hydra.Dsl.Variants + Hydra.Dsl.Workflow + Hydra.Dsl.Xml.Schema + Hydra.Dsl.Yaml.Model + Hydra.Dsls + Hydra.Encode.Ast + Hydra.Encode.Classes + Hydra.Encode.Coders + Hydra.Encode.Context + Hydra.Encode.Core + Hydra.Encode.Error.Checking + Hydra.Encode.Error.Core + Hydra.Encode.Errors + Hydra.Encode.Json.Model + Hydra.Encode.Packaging + Hydra.Encode.Parsing + Hydra.Encode.Paths + Hydra.Encode.Pg.Mapping + Hydra.Encode.Pg.Model + Hydra.Encode.Phantoms + Hydra.Encode.Query + Hydra.Encode.Relational + Hydra.Encode.Tabular + Hydra.Encode.Testing + Hydra.Encode.Topology + Hydra.Encode.Typing + Hydra.Encode.Util + Hydra.Encode.Variants + Hydra.Encoding + Hydra.Environment + Hydra.Error.Checking + Hydra.Error.Core + Hydra.Error.Packaging + Hydra.Error.Pg + Hydra.Errors + Hydra.Eval.Lib.Eithers + Hydra.Eval.Lib.Equality + Hydra.Eval.Lib.Lists + Hydra.Eval.Lib.Logic + Hydra.Eval.Lib.Maps + Hydra.Eval.Lib.Math + Hydra.Eval.Lib.Maybes + Hydra.Eval.Lib.Pairs + Hydra.Eval.Lib.Sets + Hydra.ExtGeneration + Hydra.Extract.Core + Hydra.Extract.Json + Hydra.Extract.Util + Hydra.Formatting + Hydra.Generation + Hydra.Geojson.Model + Hydra.Go.Language + Hydra.Go.Syntax + Hydra.Graph + Hydra.Graphql.Coder + Hydra.Graphql.Language + Hydra.Graphql.Serde + Hydra.Graphql.Syntax + Hydra.Graphviz.Coder + Hydra.Graphviz.Dot + Hydra.Graphviz.Serde + Hydra.Haskell.Coder + Hydra.Haskell.Environment + Hydra.Haskell.Generation + Hydra.Haskell.Language + Hydra.Haskell.Operators + Hydra.Haskell.Serde + Hydra.Haskell.Syntax + Hydra.Haskell.Testing + Hydra.Haskell.Utils + Hydra.Hoisting + Hydra.Iana.Linkrelations + Hydra.Inference + Hydra.Java.Coder + Hydra.Java.Environment + Hydra.Java.Language + Hydra.Java.Names + Hydra.Java.Serde + Hydra.Java.Syntax + Hydra.Java.Testing + Hydra.Java.Utils + Hydra.JavaScript.Language + Hydra.JavaScript.Operators + Hydra.JavaScript.Serde + Hydra.JavaScript.Syntax + Hydra.Json.Bootstrap + Hydra.Json.Decode + Hydra.Json.Decoding + Hydra.Json.Encode + Hydra.Json.Model + Hydra.Json.Parser + Hydra.Json.Schema + Hydra.Json.Schema.Coder + Hydra.Json.Schema.Language + Hydra.Json.Schema.Serde + Hydra.Json.Writer + Hydra.Json.Yaml.Decode + Hydra.Json.Yaml.Encode + Hydra.Kernel + Hydra.Kusto.Kql + Hydra.Languages + Hydra.Lexical + Hydra.Lib.Chars + Hydra.Lib.Eithers + Hydra.Lib.Equality + Hydra.Lib.Lists + Hydra.Lib.Literals + Hydra.Lib.Logic + Hydra.Lib.Maps + Hydra.Lib.Math + Hydra.Lib.Maybes + Hydra.Lib.Names + Hydra.Lib.Pairs + Hydra.Lib.Regex + Hydra.Lib.Sets + Hydra.Lib.Strings + Hydra.Lisp.Coder + Hydra.Lisp.Language + Hydra.Lisp.Serde + Hydra.Lisp.Syntax + Hydra.Literals + Hydra.Minimal + Hydra.Module.Compat + Hydra.Names + Hydra.Osv.Schema + Hydra.Owl.Syntax + Hydra.PackageRouting + Hydra.Packaging + Hydra.Parquet.Format + Hydra.Parsers + Hydra.Parsing + Hydra.Paths + Hydra.Pegasus.Coder + Hydra.Pegasus.Language + Hydra.Pegasus.Pdl + Hydra.Pegasus.Serde + Hydra.Pg.Coder + Hydra.Pg.Graphson.Coder + Hydra.Pg.Graphson.Construct + Hydra.Pg.Graphson.Syntax + Hydra.Pg.Graphson.Utils + Hydra.Pg.Mapping + Hydra.Pg.Model + Hydra.Pg.Printing + Hydra.Pg.Query + Hydra.Pg.Rdf.Environment + Hydra.Pg.Rdf.Mappings + Hydra.Pg.TermsToElements + Hydra.Pg.Utils + Hydra.Phantoms + Hydra.Predicates + Hydra.Protobuf.Any + Hydra.Protobuf.Coder + Hydra.Protobuf.Environment + Hydra.Protobuf.Language + Hydra.Protobuf.Proto3 + Hydra.Protobuf.Serde + Hydra.Protobuf.SourceContext + Hydra.Python.Coder + Hydra.Python.Environment + Hydra.Python.Language + Hydra.Python.Names + Hydra.Python.Serde + Hydra.Python.Syntax + Hydra.Python.Testing + Hydra.Python.Utils + Hydra.Query + Hydra.Rdf.Serde + Hydra.Rdf.Syntax + Hydra.Rdf.Utils + Hydra.Reduction + Hydra.Reflect + Hydra.Relational + Hydra.Resolution + Hydra.Rewriting + Hydra.Rust.Coder + Hydra.Rust.Language + Hydra.Rust.Operators + Hydra.Rust.Serde + Hydra.Rust.Syntax + Hydra.Scala.Coder + Hydra.Scala.Language + Hydra.Scala.Prepare + Hydra.Scala.Serde + Hydra.Scala.Syntax + Hydra.Scala.Utils + Hydra.Scoping + Hydra.Serialization + Hydra.Settings + Hydra.Shacl.Coder + Hydra.Shacl.Language + Hydra.Shacl.Model + Hydra.Shex.Syntax + Hydra.Show.Core + Hydra.Show.Error.Core + Hydra.Show.Errors + Hydra.Show.Graph + Hydra.Show.Paths + Hydra.Show.Typing + Hydra.Show.Util + Hydra.Show.Variants + Hydra.Sorting + Hydra.Sources.All + Hydra.Sources.Avro.Coder + Hydra.Sources.Avro.Encoder + Hydra.Sources.Avro.Environment + Hydra.Sources.Avro.Language + Hydra.Sources.Avro.Schema + Hydra.Sources.Avro.SchemaJson + Hydra.Sources.Avro.Testing + Hydra.Sources.Coq.Coder + Hydra.Sources.Coq.Environment + Hydra.Sources.Coq.Generate + Hydra.Sources.Coq.Language + Hydra.Sources.Coq.Manifest + Hydra.Sources.Coq.Serde + Hydra.Sources.Coq.Syntax + Hydra.Sources.Coq.Utils + Hydra.Sources.Cpp.Coder + Hydra.Sources.Cpp.Environment + Hydra.Sources.Cpp.Language + Hydra.Sources.Cpp.Names + Hydra.Sources.Cpp.Serde + Hydra.Sources.Cpp.Syntax + Hydra.Sources.Cpp.Utils + Hydra.Sources.Csharp.Language + Hydra.Sources.Csharp.Syntax + Hydra.Sources.Cypher.Features + Hydra.Sources.Cypher.Functions + Hydra.Sources.Cypher.OpenCypher + Hydra.Sources.Decode.Ast + Hydra.Sources.Decode.Classes + Hydra.Sources.Decode.Coders + Hydra.Sources.Decode.Context + Hydra.Sources.Decode.Core + Hydra.Sources.Decode.Error.Checking + Hydra.Sources.Decode.Error.Core + Hydra.Sources.Decode.Error.Packaging + Hydra.Sources.Decode.Errors + Hydra.Sources.Decode.Json.Model + Hydra.Sources.Decode.Packaging + Hydra.Sources.Decode.Parsing + Hydra.Sources.Decode.Paths + Hydra.Sources.Decode.Pg.Mapping + Hydra.Sources.Decode.Pg.Model + Hydra.Sources.Decode.Phantoms + Hydra.Sources.Decode.Query + Hydra.Sources.Decode.Relational + Hydra.Sources.Decode.Tabular + Hydra.Sources.Decode.Testing + Hydra.Sources.Decode.Topology + Hydra.Sources.Decode.Typing + Hydra.Sources.Decode.Util + Hydra.Sources.Decode.Variants + Hydra.Sources.Delta.Parquet + Hydra.Sources.Demos.GenPG.Transform + Hydra.Sources.Encode.Ast + Hydra.Sources.Encode.Classes + Hydra.Sources.Encode.Coders + Hydra.Sources.Encode.Context + Hydra.Sources.Encode.Core + Hydra.Sources.Encode.Error.Checking + Hydra.Sources.Encode.Error.Core + Hydra.Sources.Encode.Error.Packaging + Hydra.Sources.Encode.Errors + Hydra.Sources.Encode.Json.Model + Hydra.Sources.Encode.Packaging + Hydra.Sources.Encode.Parsing + Hydra.Sources.Encode.Paths + Hydra.Sources.Encode.Pg.Mapping + Hydra.Sources.Encode.Pg.Model + Hydra.Sources.Encode.Phantoms + Hydra.Sources.Encode.Query + Hydra.Sources.Encode.Relational + Hydra.Sources.Encode.Tabular + Hydra.Sources.Encode.Testing + Hydra.Sources.Encode.Topology + Hydra.Sources.Encode.Typing + Hydra.Sources.Encode.Util + Hydra.Sources.Encode.Variants + Hydra.Sources.Error.Pg + Hydra.Sources.Eval.Lib.All + Hydra.Sources.Eval.Lib.Eithers + Hydra.Sources.Eval.Lib.Equality + Hydra.Sources.Eval.Lib.Lists + Hydra.Sources.Eval.Lib.Logic + Hydra.Sources.Eval.Lib.Maps + Hydra.Sources.Eval.Lib.Math + Hydra.Sources.Eval.Lib.Maybes + Hydra.Sources.Eval.Lib.Pairs + Hydra.Sources.Eval.Lib.Sets + Hydra.Sources.Ext + Hydra.Sources.Ext.Manifest + Hydra.Sources.Go.Language + Hydra.Sources.Go.Serde + Hydra.Sources.Go.Syntax + Hydra.Sources.Gql.OpenGql + Hydra.Sources.Gql.PathAlgebra.Expressions + Hydra.Sources.Gql.PathAlgebra.Syntax + Hydra.Sources.Graphql.Coder + Hydra.Sources.Graphql.Language + Hydra.Sources.Graphql.Serde + Hydra.Sources.Graphql.Syntax + Hydra.Sources.Graphviz.Coder + Hydra.Sources.Graphviz.Dot + Hydra.Sources.Graphviz.Serde + Hydra.Sources.Haskell.Coder + Hydra.Sources.Haskell.Environment + Hydra.Sources.Haskell.Language + Hydra.Sources.Haskell.Manifest + Hydra.Sources.Haskell.Operators + Hydra.Sources.Haskell.Serde + Hydra.Sources.Haskell.Syntax + Hydra.Sources.Haskell.Testing + Hydra.Sources.Haskell.Utils + Hydra.Sources.Java.Coder + Hydra.Sources.Java.Environment + Hydra.Sources.Java.Language + Hydra.Sources.Java.Manifest + Hydra.Sources.Java.Names + Hydra.Sources.Java.Serde + Hydra.Sources.Java.Syntax + Hydra.Sources.Java.Testing + Hydra.Sources.Java.Utils + Hydra.Sources.JavaScript.Language + Hydra.Sources.JavaScript.Manifest + Hydra.Sources.JavaScript.Operators + Hydra.Sources.JavaScript.Serde + Hydra.Sources.JavaScript.Syntax + Hydra.Sources.Json.Bootstrap + Hydra.Sources.Json.Decode + Hydra.Sources.Json.Decoding + Hydra.Sources.Json.Encode + Hydra.Sources.Json.Extract + Hydra.Sources.Json.Model + Hydra.Sources.Json.Parser + Hydra.Sources.Json.Schema + Hydra.Sources.Json.Schema.Coder + Hydra.Sources.Json.Schema.Language + Hydra.Sources.Json.Schema.Serde + Hydra.Sources.Json.Writer + Hydra.Sources.Json.Yaml.Decode + Hydra.Sources.Json.Yaml.Encode + Hydra.Sources.Kernel.Lib.Names + Hydra.Sources.Kernel.Manifest + Hydra.Sources.Kernel.Terms.Adapt + Hydra.Sources.Kernel.Terms.All + Hydra.Sources.Kernel.Terms.Analysis + Hydra.Sources.Kernel.Terms.Annotations + Hydra.Sources.Kernel.Terms.Arity + Hydra.Sources.Kernel.Terms.Checking + Hydra.Sources.Kernel.Terms.Constants + Hydra.Sources.Kernel.Terms.Decoding + Hydra.Sources.Kernel.Terms.Dependencies + Hydra.Sources.Kernel.Terms.Differentiation + Hydra.Sources.Kernel.Terms.Dsls + Hydra.Sources.Kernel.Terms.Encoding + Hydra.Sources.Kernel.Terms.Environment + Hydra.Sources.Kernel.Terms.Extract.Core + Hydra.Sources.Kernel.Terms.Extract.Util + Hydra.Sources.Kernel.Terms.Formatting + Hydra.Sources.Kernel.Terms.Generation + Hydra.Sources.Kernel.Terms.Hoisting + Hydra.Sources.Kernel.Terms.Inference + Hydra.Sources.Kernel.Terms.Languages + Hydra.Sources.Kernel.Terms.Lexical + Hydra.Sources.Kernel.Terms.Literals + Hydra.Sources.Kernel.Terms.Names + Hydra.Sources.Kernel.Terms.Parsers + Hydra.Sources.Kernel.Terms.Predicates + Hydra.Sources.Kernel.Terms.Reduction + Hydra.Sources.Kernel.Terms.Reflect + Hydra.Sources.Kernel.Terms.Resolution + Hydra.Sources.Kernel.Terms.Rewriting + Hydra.Sources.Kernel.Terms.Scoping + Hydra.Sources.Kernel.Terms.Serialization + Hydra.Sources.Kernel.Terms.Show.Core + Hydra.Sources.Kernel.Terms.Show.Error.Core + Hydra.Sources.Kernel.Terms.Show.Errors + Hydra.Sources.Kernel.Terms.Show.Graph + Hydra.Sources.Kernel.Terms.Show.Paths + Hydra.Sources.Kernel.Terms.Show.Typing + Hydra.Sources.Kernel.Terms.Show.Util + Hydra.Sources.Kernel.Terms.Show.Variants + Hydra.Sources.Kernel.Terms.Sorting + Hydra.Sources.Kernel.Terms.Strip + Hydra.Sources.Kernel.Terms.Substitution + Hydra.Sources.Kernel.Terms.Templates + Hydra.Sources.Kernel.Terms.Unification + Hydra.Sources.Kernel.Terms.Validate.Core + Hydra.Sources.Kernel.Terms.Validate.Packaging + Hydra.Sources.Kernel.Terms.Variables + Hydra.Sources.Kernel.Types.All + Hydra.Sources.Kernel.Types.Ast + Hydra.Sources.Kernel.Types.Classes + Hydra.Sources.Kernel.Types.Coders + Hydra.Sources.Kernel.Types.Context + Hydra.Sources.Kernel.Types.Core + Hydra.Sources.Kernel.Types.Error.Checking + Hydra.Sources.Kernel.Types.Error.Core + Hydra.Sources.Kernel.Types.Error.Packaging + Hydra.Sources.Kernel.Types.Errors + Hydra.Sources.Kernel.Types.Graph + Hydra.Sources.Kernel.Types.Packaging + Hydra.Sources.Kernel.Types.Parsing + Hydra.Sources.Kernel.Types.Paths + Hydra.Sources.Kernel.Types.Phantoms + Hydra.Sources.Kernel.Types.Query + Hydra.Sources.Kernel.Types.Relational + Hydra.Sources.Kernel.Types.Tabular + Hydra.Sources.Kernel.Types.Testing + Hydra.Sources.Kernel.Types.Topology + Hydra.Sources.Kernel.Types.Typing + Hydra.Sources.Kernel.Types.Util + Hydra.Sources.Kernel.Types.Variants + Hydra.Sources.Kusto.Kql + Hydra.Sources.Libraries + Hydra.Sources.Lisp.Coder + Hydra.Sources.Lisp.Language + Hydra.Sources.Lisp.Manifest + Hydra.Sources.Lisp.Serde + Hydra.Sources.Lisp.Syntax + Hydra.Sources.Other.Atlas + Hydra.Sources.Other.AzureDtld + Hydra.Sources.Other.Datalog + Hydra.Sources.Other.GeoJson + Hydra.Sources.Other.IanaRelations + Hydra.Sources.Other.Osv + Hydra.Sources.Other.StacItems + Hydra.Sources.Owl.Syntax + Hydra.Sources.Parquet.Format + Hydra.Sources.Pegasus.Coder + Hydra.Sources.Pegasus.Language + Hydra.Sources.Pegasus.Pdl + Hydra.Sources.Pegasus.Serde + Hydra.Sources.Pg.Coder + Hydra.Sources.Pg.Graphson.Coder + Hydra.Sources.Pg.Graphson.Construct + Hydra.Sources.Pg.Graphson.Syntax + Hydra.Sources.Pg.Graphson.Utils + Hydra.Sources.Pg.Manifest + Hydra.Sources.Pg.Mapping + Hydra.Sources.Pg.Model + Hydra.Sources.Pg.Printing + Hydra.Sources.Pg.Query + Hydra.Sources.Pg.Rdf.Environment + Hydra.Sources.Pg.Rdf.Mappings + Hydra.Sources.Pg.TermsToElements + Hydra.Sources.Pg.Utils + Hydra.Sources.Protobuf.Any + Hydra.Sources.Protobuf.Coder + Hydra.Sources.Protobuf.Environment + Hydra.Sources.Protobuf.Language + Hydra.Sources.Protobuf.Proto3 + Hydra.Sources.Protobuf.Serde + Hydra.Sources.Protobuf.SourceContext + Hydra.Sources.Python.Coder + Hydra.Sources.Python.Environment + Hydra.Sources.Python.Language + Hydra.Sources.Python.Manifest + Hydra.Sources.Python.Names + Hydra.Sources.Python.Serde + Hydra.Sources.Python.Syntax + Hydra.Sources.Python.Testing + Hydra.Sources.Python.Utils + Hydra.Sources.Rdf.Manifest + Hydra.Sources.Rdf.Serde + Hydra.Sources.Rdf.Syntax + Hydra.Sources.Rdf.Utils + Hydra.Sources.Rust.Coder + Hydra.Sources.Rust.Language + Hydra.Sources.Rust.Operators + Hydra.Sources.Rust.Serde + Hydra.Sources.Rust.Syntax + Hydra.Sources.Scala.Coder + Hydra.Sources.Scala.Language + Hydra.Sources.Scala.Manifest + Hydra.Sources.Scala.Prepare + Hydra.Sources.Scala.Serde + Hydra.Sources.Scala.Syntax + Hydra.Sources.Scala.Utils + Hydra.Sources.Shacl.Coder + Hydra.Sources.Shacl.Language + Hydra.Sources.Shacl.Model + Hydra.Sources.Shex.Syntax + Hydra.Sources.Sql.Ansi + Hydra.Sources.Test.All + Hydra.Sources.Test.Annotations + Hydra.Sources.Test.Checking.Advanced + Hydra.Sources.Test.Checking.AlgebraicTypes + Hydra.Sources.Test.Checking.All + Hydra.Sources.Test.Checking.Collections + Hydra.Sources.Test.Checking.Failures + Hydra.Sources.Test.Checking.Fundamentals + Hydra.Sources.Test.Checking.NominalTypes + Hydra.Sources.Test.Dependencies + Hydra.Sources.Test.Differentiation + Hydra.Sources.Test.EtaExpansion + Hydra.Sources.Test.Formatting + Hydra.Sources.Test.Generation + Hydra.Sources.Test.Hoisting.All + Hydra.Sources.Test.Hoisting.Cases + Hydra.Sources.Test.Hoisting.Let + Hydra.Sources.Test.Inference.AlgebraicTypes + Hydra.Sources.Test.Inference.AlgorithmW + Hydra.Sources.Test.Inference.All + Hydra.Sources.Test.Inference.Classes + Hydra.Sources.Test.Inference.Failures + Hydra.Sources.Test.Inference.Fundamentals + Hydra.Sources.Test.Inference.KernelExamples + Hydra.Sources.Test.Inference.NominalTypes + Hydra.Sources.Test.Json.Parser + Hydra.Sources.Test.Json.Roundtrip + Hydra.Sources.Test.Json.Writer + Hydra.Sources.Test.Json.Yaml + Hydra.Sources.Test.Lib.Chars + Hydra.Sources.Test.Lib.Eithers + Hydra.Sources.Test.Lib.Equality + Hydra.Sources.Test.Lib.Lists + Hydra.Sources.Test.Lib.Literals + Hydra.Sources.Test.Lib.Logic + Hydra.Sources.Test.Lib.Maps + Hydra.Sources.Test.Lib.Math + Hydra.Sources.Test.Lib.Maybes + Hydra.Sources.Test.Lib.Pairs + Hydra.Sources.Test.Lib.Regex + Hydra.Sources.Test.Lib.Sets + Hydra.Sources.Test.Lib.Strings + Hydra.Sources.Test.Ordering + Hydra.Sources.Test.Reduction + Hydra.Sources.Test.Rewriting + Hydra.Sources.Test.Serialization + Hydra.Sources.Test.Sorting + Hydra.Sources.Test.Strip + Hydra.Sources.Test.Substitution + Hydra.Sources.Test.TestEnv + Hydra.Sources.Test.TestGraph + Hydra.Sources.Test.TestSuite + Hydra.Sources.Test.TestTerms + Hydra.Sources.Test.TestTypes + Hydra.Sources.Test.Transform + Hydra.Sources.Test.Unification + Hydra.Sources.Test.Utils + Hydra.Sources.Test.Validate.All + Hydra.Sources.Test.Validate.Core + Hydra.Sources.Test.Variables + Hydra.Sources.Tinkerpop.Features + Hydra.Sources.Tinkerpop.Gremlin + Hydra.Sources.Tinkerpop.Language + Hydra.Sources.TypeScript.Language + Hydra.Sources.TypeScript.Model + Hydra.Sources.Validate.Pg + Hydra.Sources.Wasm.Coder + Hydra.Sources.Wasm.Language + Hydra.Sources.Wasm.Manifest + Hydra.Sources.Wasm.Serde + Hydra.Sources.Wasm.Syntax + Hydra.Sources.Workflow + Hydra.Sources.Xml.Schema + Hydra.Sources.Yaml.Coder + Hydra.Sources.Yaml.Language + Hydra.Sources.Yaml.Model + Hydra.Sources.Yaml.Serde + Hydra.Sql.Syntax + Hydra.Stac.Items + Hydra.Strip + Hydra.Substitution + Hydra.Tabular + Hydra.Templates + Hydra.Test.Transform + Hydra.Test.Utils + Hydra.Testing + Hydra.Tinkerpop.Features + Hydra.Tinkerpop.Gremlin + Hydra.Tinkerpop.Language + Hydra.Tools.AvroWorkflows + Hydra.Tools.Bytestrings + Hydra.Tools.Csv + Hydra.Tools.Debug + Hydra.Tools.Tabular + Hydra.Topology + Hydra.TypeScript.Language + Hydra.TypeScript.Model + Hydra.Typing + Hydra.Unification + Hydra.Util + Hydra.Validate.Core + Hydra.Validate.Packaging + Hydra.Validate.Pg + Hydra.Variables + Hydra.Variants + Hydra.Wasm.Coder + Hydra.Wasm.Language + Hydra.Wasm.Serde + Hydra.Wasm.Syntax + Hydra.Workflow + Hydra.Xml.Schema + Hydra.Yaml.Coder + Hydra.Yaml.Language + Hydra.Yaml.Model + Hydra.Yaml.Serde + OpenGql.Grammar + other-modules: + Paths_hydra + hs-source-dirs: + src/main/haskell + build-depends: + SHA >=1.6.4 && <1.7 + , aeson >=2.1.0 && <2.3 + , base >=4.19.0 && <4.22 + , base64-bytestring >=1.2.1 && <1.3 + , bytestring >=0.11.5 && <0.13 + , containers >=0.6.7 && <0.8 + , directory >=1.3.6 && <1.4 + , filepath >=1.4.200 && <1.6 + , regex-tdfa >=1.3.2 && <1.4 + , scientific >=0.3.7 && <0.4 + , split >=0.2.3 && <0.3 + , text >=2.0.2 && <2.2 + , vector >=0.12.0 && <0.14 + default-language: Haskell2010 + +executable bootstrap-from-json + main-is: Main.hs + other-modules: + Paths_hydra + hs-source-dirs: + src/exec/bootstrap-from-json + ghc-options: -rtsopts + build-depends: + SHA >=1.6.4 && <1.7 + , aeson >=2.1.0 && <2.3 + , base >=4.19.0 && <4.22 + , base64-bytestring >=1.2.1 && <1.3 + , bytestring >=0.11.5 && <0.13 + , containers >=0.6.7 && <0.8 + , directory >=1.3.6 && <1.4 + , filepath >=1.4.200 && <1.6 + , hspec >=2.11.0 && <2.12 + , hydra + , regex-tdfa >=1.3.2 && <1.4 + , scientific >=0.3.7 && <0.4 + , split >=0.2.3 && <0.3 + , text >=2.0.2 && <2.2 + , time + , vector >=0.12.0 && <0.14 + default-language: Haskell2010 + +executable diag-module + main-is: Main.hs + other-modules: + Paths_hydra + hs-source-dirs: + src/exec/diag-module + ghc-options: -rtsopts + build-depends: + SHA >=1.6.4 && <1.7 + , aeson >=2.1.0 && <2.3 + , base >=4.19.0 && <4.22 + , base64-bytestring >=1.2.1 && <1.3 + , bytestring >=0.11.5 && <0.13 + , containers >=0.6.7 && <0.8 + , directory >=1.3.6 && <1.4 + , filepath >=1.4.200 && <1.6 + , hydra + , regex-tdfa >=1.3.2 && <1.4 + , scientific >=0.3.7 && <0.4 + , split >=0.2.3 && <0.3 + , text >=2.0.2 && <2.2 + , vector >=0.12.0 && <0.14 + default-language: Haskell2010 + +executable digest-check + main-is: Main.hs + other-modules: + Paths_hydra + hs-source-dirs: + src/exec/digest-check + ghc-options: -rtsopts + build-depends: + SHA >=1.6.4 && <1.7 + , aeson >=2.1.0 && <2.3 + , base >=4.19.0 && <4.22 + , base64-bytestring >=1.2.1 && <1.3 + , bytestring >=0.11.5 && <0.13 + , containers >=0.6.7 && <0.8 + , directory >=1.3.6 && <1.4 + , filepath >=1.4.200 && <1.6 + , hydra + , regex-tdfa >=1.3.2 && <1.4 + , scientific >=0.3.7 && <0.4 + , split >=0.2.3 && <0.3 + , text >=2.0.2 && <2.2 + , vector >=0.12.0 && <0.14 + default-language: Haskell2010 + +executable generate-coq + main-is: Main.hs + other-modules: + Paths_hydra + hs-source-dirs: + src/exec/generate-coq + ghc-options: -rtsopts + build-depends: + SHA >=1.6.4 && <1.7 + , aeson >=2.1.0 && <2.3 + , base >=4.19.0 && <4.22 + , base64-bytestring >=1.2.1 && <1.3 + , bytestring >=0.11.5 && <0.13 + , containers >=0.6.7 && <0.8 + , directory >=1.3.6 && <1.4 + , filepath >=1.4.200 && <1.6 + , hydra + , regex-tdfa >=1.3.2 && <1.4 + , scientific >=0.3.7 && <0.4 + , split >=0.2.3 && <0.3 + , text >=2.0.2 && <2.2 + , vector >=0.12.0 && <0.14 + default-language: Haskell2010 + +executable generate-coq-tests + main-is: Main.hs + other-modules: + Paths_hydra + hs-source-dirs: + src/exec/generate-coq-tests + ghc-options: -rtsopts + build-depends: + SHA >=1.6.4 && <1.7 + , aeson >=2.1.0 && <2.3 + , base >=4.19.0 && <4.22 + , base64-bytestring >=1.2.1 && <1.3 + , bytestring >=0.11.5 && <0.13 + , containers >=0.6.7 && <0.8 + , directory >=1.3.6 && <1.4 + , filepath >=1.4.200 && <1.6 + , hydra + , regex-tdfa >=1.3.2 && <1.4 + , scientific >=0.3.7 && <0.4 + , split >=0.2.3 && <0.3 + , text >=2.0.2 && <2.2 + , vector >=0.12.0 && <0.14 + default-language: Haskell2010 + +executable transform-haskell-dsl-to-json + main-is: Main.hs + other-modules: + Paths_hydra + hs-source-dirs: + src/exec/transform-haskell-dsl-to-json + ghc-options: -rtsopts + build-depends: + SHA >=1.6.4 && <1.7 + , aeson >=2.1.0 && <2.3 + , base >=4.19.0 && <4.22 + , base64-bytestring >=1.2.1 && <1.3 + , bytestring >=0.11.5 && <0.13 + , containers >=0.6.7 && <0.8 + , directory >=1.3.6 && <1.4 + , filepath >=1.4.200 && <1.6 + , hydra + , regex-tdfa >=1.3.2 && <1.4 + , scientific >=0.3.7 && <0.4 + , split >=0.2.3 && <0.3 + , text >=2.0.2 && <2.2 + , vector >=0.12.0 && <0.14 + default-language: Haskell2010 + +executable update-json-kernel + main-is: Main.hs + other-modules: + Paths_hydra + hs-source-dirs: + src/exec/update-json-kernel + ghc-options: -rtsopts + build-depends: + SHA >=1.6.4 && <1.7 + , aeson >=2.1.0 && <2.3 + , base >=4.19.0 && <4.22 + , base64-bytestring >=1.2.1 && <1.3 + , bytestring >=0.11.5 && <0.13 + , containers >=0.6.7 && <0.8 + , directory >=1.3.6 && <1.4 + , filepath >=1.4.200 && <1.6 + , hydra + , regex-tdfa >=1.3.2 && <1.4 + , scientific >=0.3.7 && <0.4 + , split >=0.2.3 && <0.3 + , text >=2.0.2 && <2.2 + , vector >=0.12.0 && <0.14 + default-language: Haskell2010 + +executable update-json-main + main-is: Main.hs + other-modules: + Paths_hydra + hs-source-dirs: + src/exec/update-json-main + ghc-options: -rtsopts + build-depends: + SHA >=1.6.4 && <1.7 + , aeson >=2.1.0 && <2.3 + , base >=4.19.0 && <4.22 + , base64-bytestring >=1.2.1 && <1.3 + , bytestring >=0.11.5 && <0.13 + , containers >=0.6.7 && <0.8 + , directory >=1.3.6 && <1.4 + , filepath >=1.4.200 && <1.6 + , hydra + , regex-tdfa >=1.3.2 && <1.4 + , scientific >=0.3.7 && <0.4 + , split >=0.2.3 && <0.3 + , text >=2.0.2 && <2.2 + , vector >=0.12.0 && <0.14 + default-language: Haskell2010 + +executable update-json-manifest + main-is: Main.hs + other-modules: + Paths_hydra + hs-source-dirs: + src/exec/update-json-manifest + ghc-options: -rtsopts + build-depends: + SHA >=1.6.4 && <1.7 + , aeson >=2.1.0 && <2.3 + , base >=4.19.0 && <4.22 + , base64-bytestring >=1.2.1 && <1.3 + , bytestring >=0.11.5 && <0.13 + , containers >=0.6.7 && <0.8 + , directory >=1.3.6 && <1.4 + , filepath >=1.4.200 && <1.6 + , hydra + , regex-tdfa >=1.3.2 && <1.4 + , scientific >=0.3.7 && <0.4 + , split >=0.2.3 && <0.3 + , text >=2.0.2 && <2.2 + , vector >=0.12.0 && <0.14 + default-language: Haskell2010 + +executable update-json-test + main-is: Main.hs + other-modules: + Paths_hydra + hs-source-dirs: + src/exec/update-json-test + ghc-options: -rtsopts + build-depends: + SHA >=1.6.4 && <1.7 + , aeson >=2.1.0 && <2.3 + , base >=4.19.0 && <4.22 + , base64-bytestring >=1.2.1 && <1.3 + , bytestring >=0.11.5 && <0.13 + , containers >=0.6.7 && <0.8 + , directory >=1.3.6 && <1.4 + , filepath >=1.4.200 && <1.6 + , hydra + , regex-tdfa >=1.3.2 && <1.4 + , scientific >=0.3.7 && <0.4 + , split >=0.2.3 && <0.3 + , text >=2.0.2 && <2.2 + , vector >=0.12.0 && <0.14 + default-language: Haskell2010 + +executable update-wasm + main-is: Main.hs + other-modules: + Paths_hydra + hs-source-dirs: + src/exec/update-wasm + ghc-options: -rtsopts + build-depends: + SHA >=1.6.4 && <1.7 + , aeson >=2.1.0 && <2.3 + , base >=4.19.0 && <4.22 + , base64-bytestring >=1.2.1 && <1.3 + , bytestring >=0.11.5 && <0.13 + , containers >=0.6.7 && <0.8 + , directory >=1.3.6 && <1.4 + , filepath >=1.4.200 && <1.6 + , hydra + , regex-tdfa >=1.3.2 && <1.4 + , scientific >=0.3.7 && <0.4 + , split >=0.2.3 && <0.3 + , text >=2.0.2 && <2.2 + , vector >=0.12.0 && <0.14 + default-language: Haskell2010 + +executable verify-json-kernel + main-is: Main.hs + other-modules: + Paths_hydra + hs-source-dirs: + src/exec/verify-json-kernel + ghc-options: -rtsopts + build-depends: + SHA >=1.6.4 && <1.7 + , aeson >=2.1.0 && <2.3 + , base >=4.19.0 && <4.22 + , base64-bytestring >=1.2.1 && <1.3 + , bytestring >=0.11.5 && <0.13 + , containers >=0.6.7 && <0.8 + , directory >=1.3.6 && <1.4 + , filepath >=1.4.200 && <1.6 + , hydra + , regex-tdfa >=1.3.2 && <1.4 + , scientific >=0.3.7 && <0.4 + , split >=0.2.3 && <0.3 + , text >=2.0.2 && <2.2 + , vector >=0.12.0 && <0.14 + default-language: Haskell2010 + +test-suite hydra-test + type: exitcode-stdio-1.0 + main-is: Spec.hs + other-modules: + Hydra.ArbitraryCore + Hydra.CoreCodersSpec + Hydra.Dsl.TypesSpec + Hydra.EvalPrimitives + Hydra.Reference.AlgorithmW + Hydra.Reference.AlgorithmWBridge + Hydra.Reference.AlgorithmWSpec + Hydra.Test.Annotations + Hydra.Test.Checking.Advanced + Hydra.Test.Checking.AlgebraicTypes + Hydra.Test.Checking.All + Hydra.Test.Checking.Collections + Hydra.Test.Checking.Failures + Hydra.Test.Checking.Fundamentals + Hydra.Test.Checking.NominalTypes + Hydra.Test.Dependencies + Hydra.Test.Differentiation + Hydra.Test.EtaExpansion + Hydra.Test.Formatting + Hydra.Test.Generation + Hydra.Test.Hoisting.All + Hydra.Test.Hoisting.Cases + Hydra.Test.Hoisting.Let + Hydra.Test.Inference.AlgebraicTypes + Hydra.Test.Inference.AlgorithmW + Hydra.Test.Inference.All + Hydra.Test.Inference.Classes + Hydra.Test.Inference.Failures + Hydra.Test.Inference.Fundamentals + Hydra.Test.Inference.KernelExamples + Hydra.Test.Inference.NominalTypes + Hydra.Test.Json.Roundtrip + Hydra.Test.Json.Writer + Hydra.Test.Json.Yaml + Hydra.Test.Lib.Chars + Hydra.Test.Lib.Eithers + Hydra.Test.Lib.Equality + Hydra.Test.Lib.Lists + Hydra.Test.Lib.Literals + Hydra.Test.Lib.Logic + Hydra.Test.Lib.Maps + Hydra.Test.Lib.Math + Hydra.Test.Lib.Maybes + Hydra.Test.Lib.Pairs + Hydra.Test.Lib.Regex + Hydra.Test.Lib.Sets + Hydra.Test.Lib.Strings + Hydra.Test.Reduction + Hydra.Test.Rewriting + Hydra.Test.Serialization + Hydra.Test.Sorting + Hydra.Test.Strip + Hydra.Test.Substitution + Hydra.Test.TestEnv + Hydra.Test.TestGraph + Hydra.Test.TestSuite + Hydra.Test.TestTerms + Hydra.Test.TestTypes + Hydra.Test.Unification + Hydra.Test.Validate.All + Hydra.Test.Validate.Core + Hydra.Test.Variables + Hydra.TestData + Hydra.TestSuiteSpec + Hydra.TestUtils + Paths_hydra + hs-source-dirs: + src/test/haskell + build-depends: + HUnit + , QuickCheck + , SHA >=1.6.4 && <1.7 , aeson >=2.1.0 && <2.3 , base >=4.19.0 && <4.22 , base64-bytestring >=1.2.1 && <1.3 diff --git a/src/exec/bootstrap-from-json/Main.hs b/src/exec/bootstrap-from-json/Main.hs new file mode 100644 --- /dev/null +++ b/src/exec/bootstrap-from-json/Main.hs @@ -0,0 +1,743 @@ +-- | Unified executable for generating code from JSON modules. +-- +-- Loads Hydra modules from pre-built JSON (no Haskell DSL compilation or type +-- inference needed) and generates code for a target language. +-- +-- Used by both: +-- - sync-java.sh / sync-python.sh (repo sync, writes to hydra-java / hydra-python) +-- - haskell-to-*.sh (bootstrapping demo, writes to /tmp) +-- +-- JSON sources: +-- dist/json/hydra-kernel/src/main/json/ — kernel, eval lib, and other modules +-- dist/json/hydra-kernel/src/test/json/ — test modules +-- hydra-ext/../../dist/json/hydra-ext/src/main/json/ — ext coder modules (Java/Python coders) +-- +-- Usage: +-- bootstrap-from-json --target [OPTIONS] +-- +-- Options: +-- --output Output base directory (default: repo target dir) +-- --include-coders Also load and generate ext coder modules +-- --include-tests Also load and generate kernel test modules +-- --kernel-only Only generate kernel modules (exclude ext coder modules) +-- --types-only Only generate type-defining modules +-- --ext-only Only generate hydraExtDemoModules from ext manifest +-- --dist-json-root Override JSON root directory + +{-# LANGUAGE ScopedTypeVariables #-} +module Main where + +import Hydra.Kernel +import Hydra.Generation +import Hydra.PackageRouting (groupByPackage, namespaceToPackage, packagePrefixes) +import qualified Hydra.Digest as Digest +import Hydra.Sources.All (kernelModules) +import Hydra.ExtGeneration (moduleToLispDialect, wrapLongLinesInScalaTree) +import Hydra.Haskell.Coder (moduleToHaskell) +import Hydra.Haskell.Language (haskellLanguage) +import Hydra.Java.Coder (moduleToJava) +import Hydra.Java.Language (javaLanguage) +import Hydra.Python.Coder (moduleToPython) +import Hydra.Python.Language (pythonLanguage) +import Hydra.Scala.Coder (moduleToScala) +import Hydra.Scala.Language (scalaLanguage) +import Hydra.Lisp.Language (lispLanguage) +import qualified Hydra.Lisp.Syntax as LispSyntax +import qualified Hydra.Sources.Test.TestSuite as TestSuite +import Hydra.Sources.Test.All (testSkipEmitNamespaces) + +import Control.Exception (catch, IOException) +import Control.Monad (when, forM) +import qualified Control.Monad as CM +import qualified Data.Char as C +import Data.List (isPrefixOf, partition) +import qualified Data.List as L +import qualified Data.List.Split as LS +import qualified Data.Map as M +import Data.Time.Clock (getCurrentTime, diffUTCTime, UTCTime) +import System.Directory (listDirectory, doesFileExist) +import qualified System.Directory as SD +import System.Environment (getArgs) +import System.Exit (exitFailure) +import System.IO (hSetBuffering, BufferMode(NoBuffering), stdout) +import qualified System.FilePath as FP + + +-- | Format elapsed time for display. +formatTime :: Double -> String +formatTime secs + | secs < 1 = show (round (secs * 1000) :: Int) ++ "ms" + | secs < 60 = show tenths ++ "s" + | otherwise = show mins ++ "m " ++ show remTenths ++ "s" + where + tenths = fromIntegral (round (secs * 10) :: Int) / 10.0 :: Double + mins = floor secs `div` 60 :: Int + remSecs = secs - fromIntegral (mins * 60) + remTenths = fromIntegral (round (remSecs * 10) :: Int) / 10.0 :: Double + +-- | Count files with a given extension in a directory tree. +countFiles :: FilePath -> String -> IO Int +countFiles dir ext = go dir + where + go d = do + entries <- listDirectory d `catch` \(_ :: IOException) -> return [] + counts <- mapM (\e -> do + let p = d FP. e + isFile <- doesFileExist p + if isFile + then return (if FP.takeExtension p == ext then 1 else 0) + else go p) entries + return (sum counts) + +data Options = Options + { optTarget :: String + , optOutput :: Maybe FilePath + , optIncludeCoders :: Bool + , optIncludeDsls :: Bool + , optIncludeTests :: Bool + , optKernelOnly :: Bool + , optTypesOnly :: Bool + , optExtOnly :: Bool + , optSynthesizeSources :: Bool + , optDistJsonRoot :: Maybe FilePath + , optPackage :: Maybe String -- Layer 1: narrow generation to one package + , optAllPackages :: Bool -- Batch mode: generate every package in one run + } + +defaultOptions :: Options +defaultOptions = Options + { optTarget = "" + , optOutput = Nothing + , optIncludeCoders = False + , optIncludeDsls = False + , optIncludeTests = False + , optKernelOnly = False + , optTypesOnly = False + , optExtOnly = False + , optSynthesizeSources = False + , optDistJsonRoot = Nothing + , optPackage = Nothing + , optAllPackages = False + } + +parseArgs :: [String] -> Either String Options +parseArgs = go defaultOptions + where + go opts [] = if Prelude.null (optTarget opts) + then Left "Missing --target" + else Right opts + go opts ("--target" : t : rest) = go (opts { optTarget = t }) rest + go opts ("--output" : o : rest) = go (opts { optOutput = Just o }) rest + go opts ("--include-coders" : rest) = go (opts { optIncludeCoders = True }) rest + go opts ("--include-dsls" : rest) = go (opts { optIncludeDsls = True }) rest + go opts ("--include-tests" : rest) = go (opts { optIncludeTests = True }) rest + go opts ("--kernel-only" : rest) = go (opts { optKernelOnly = True }) rest + go opts ("--types-only" : rest) = go (opts { optTypesOnly = True }) rest + go opts ("--ext-only" : rest) = go (opts { optExtOnly = True }) rest + go opts ("--synthesize-sources" : rest) = go (opts { optSynthesizeSources = True }) rest + go opts ("--dist-json-root" : d : rest) = go (opts { optDistJsonRoot = Just d }) rest + go opts ("--package" : p : rest) = go (opts { optPackage = Just p }) rest + go opts ("--all-packages" : rest) = go (opts { optAllPackages = True }) rest + go _ (arg : _) = Left $ "Unknown argument: " ++ arg + +usage :: String +usage = unlines + [ "Usage: bootstrap-from-json --target [OPTIONS]" + , "" + , "Options:" + , " --output Output base directory" + , " --include-coders Also load coder packages (hydra-java/python/scala/lisp)" + , " --include-dsls Also load DSL wrapper modules" + , " --include-tests Also generate kernel test modules" + , " --kernel-only Only generate kernel modules (exclude coder packages)" + , " --types-only Only generate type-defining modules" + , " --ext-only Only generate ext demo modules from hydra-pg / hydra-rdf" + , " --synthesize-sources Also synthesize decoder/encoder DSL source modules" + , " (Hydra.Sources.Decode.*, Hydra.Sources.Encode.*) from" + , " the loaded kernel type modules." + , " --dist-json-root Override the root dist/json directory (default:" + , " ../../dist/json). The tool walks" + , " //src/main/json/ for each package it" + , " needs to load, in dependency order." + , " --package Narrow generation to modules owned by ." + , " The full universe is still loaded so cross-" + , " package type references resolve." + ] + +main :: IO () +main = do + hSetBuffering stdout NoBuffering + args <- getArgs + + opts <- case parseArgs args of + Left err -> do + putStrLn $ "Error: " ++ err + putStrLn "" + putStrLn usage + exitFailure + Right o -> return o + + let target = optTarget opts + let ext = case target of + "haskell" -> ".hs" + "java" -> ".java" + "python" -> ".py" + "scala" -> ".scala" + "clojure" -> ".clj" + "scheme" -> ".scm" + "common-lisp" -> ".lisp" + "emacs-lisp" -> ".el" + _ -> "" + + -- Determine output directories + let defaultOutput = case target of + "haskell" -> "/tmp/hydra-bootstrapping-demo/haskell-to-haskell" + "java" -> "../../dist/java/hydra-kernel" + "python" -> "../../dist/python/hydra-kernel" + "scala" -> "../../dist/scala/hydra-kernel" + "clojure" -> "../../dist/clojure/hydra-kernel" + "scheme" -> "../../dist/scheme/hydra-kernel" + "common-lisp" -> "../../dist/common-lisp/hydra-kernel" + "emacs-lisp" -> "../../dist/emacs-lisp/hydra-kernel" + _ -> "/tmp/hydra-bootstrapping-demo/haskell-to-" ++ target + let outBase = maybe defaultOutput id (optOutput opts) + -- Output path convention: callers pass the parent of per-package dirs as + -- --output (e.g. --output ../../dist/haskell), and each module is routed + -- to ../../dist/haskell//src/{main,test}//. + let packageOutMain pkg = outBase FP. pkg FP. ("src/main/" ++ target) + let packageOutTest pkg = outBase FP. pkg FP. ("src/test/" ++ target) + -- Flat outMain / outTest are used by the few legacy writers (test-mode + -- ext injection below) that don't go through groupByPackage. + let outMain = outBase FP. ("src/main/" ++ target) + let outTest = outBase FP. ("src/test/" ++ target) + + -- Per-package JSON layout. Every package's main-side modules live at + -- //src/main/json/; the kernel's test modules live at + -- /hydra-kernel/src/test/json/. + let distJsonRoot = maybe "../../dist/json" id (optDistJsonRoot opts) + let pkgMainDir pkg = distJsonRoot FP. pkg FP. "src" FP. "main" FP. "json" + let kernelJsonDir = pkgMainDir "hydra-kernel" + let testJsonDir = distJsonRoot FP. "hydra-kernel" FP. "src" FP. "test" FP. "json" + + -- Dependency order: baseline packages (hydra-kernel + hydra-haskell) are + -- loaded individually in Step 1. Coder packages are loaded with + -- --include-coders. Ext demo packages are loaded with --ext-only. Other + -- non-baseline non-coder packages (extPackages and extDemoPackages) are + -- auto-loaded based on --package or --all-packages — see Step 2c. + let coderPackages = ["hydra-java", "hydra-python", "hydra-scala", "hydra-lisp"] + let extDemoPackages = ["hydra-pg", "hydra-rdf"] + let extPackages = ["hydra-coq", "hydra-javascript", "hydra-ext", "hydra-wasm"] + + let targetCap = case target of + "haskell" -> "Haskell" + "java" -> "Java" + "python" -> "Python" + "scala" -> "Scala" + "clojure" -> "Clojure" + "scheme" -> "Scheme" + "common-lisp" -> "Common Lisp" + "emacs-lisp" -> "Emacs Lisp" + t -> t + + putStrLn "==========================================" + putStrLn $ "Mapping JSON to " ++ targetCap + putStrLn "==========================================" + putStrLn "" + putStrLn $ " Target: " ++ targetCap + putStrLn $ " Output: " ++ outBase + putStrLn $ " Include coders: " ++ show (optIncludeCoders opts) + putStrLn $ " Include DSLs: " ++ show (optIncludeDsls opts) + putStrLn $ " Include tests: " ++ show (optIncludeTests opts) + putStrLn "" + + -- Load a single package's mainModules + evalLibModules from its per-package + -- manifest. Returns the accumulated Modules; missing fields are treated as + -- empty. + let loadPackageMain :: String -> IO [Module] + loadPackageMain pkg = do + let pkgDir = pkgMainDir pkg + mainNs <- readManifestFieldOrEmpty pkgDir "mainModules" + evalNs <- readManifestFieldOrEmpty pkgDir "evalLibModules" + let allNs = mainNs ++ evalNs + if Prelude.null allNs + then return [] + else do + putStrLn $ " " ++ pkg ++ ": " ++ show (length allNs) ++ " modules from " ++ pkgDir + loadModulesFromJson pkgDir kernelModules allNs + + -- Load a single package's DSL wrapper modules. + let loadPackageDsl :: String -> IO [Module] + loadPackageDsl pkg = do + let pkgDir = pkgMainDir pkg + dslNs <- readManifestFieldOrEmpty pkgDir "dslModules" + if Prelude.null dslNs + then return [] + else do + putStrLn $ " " ++ pkg ++ ": " ++ show (length dslNs) ++ " DSL modules from " ++ pkgDir + loadModulesFromJson pkgDir kernelModules dslNs + + -- Step 1: Load baseline main modules (hydra-kernel + hydra-haskell). + -- Both packages are part of the bootstrap baseline: hydra-haskell provides + -- the runtime AST modules (Hydra.Haskell.Syntax, Environment, Coder, Serde, + -- ...) that the generated DSL source modules import, so it must pass + -- --kernel-only filtering as part of the kernel namespace set. + putStrLn "Step 1: Loading baseline main modules from JSON..." + loadStart <- getCurrentTime + kernelBaselineMods <- loadPackageMain "hydra-kernel" + haskellBaselineMods <- loadPackageMain "hydra-haskell" + let baselineMods = kernelBaselineMods ++ haskellBaselineMods + loadEnd <- getCurrentTime + putStrLn $ " Loaded " ++ show (length baselineMods) ++ " baseline modules." + putStrLn $ " Time: " ++ formatTime (elapsed loadEnd loadStart) + putStrLn "" + + let allKernelNamespaces = fmap moduleNamespace baselineMods + + -- Step 2: Optionally load coder-package main modules. + coderMods <- if optIncludeCoders opts + then do + putStrLn "Step 2: Loading coder package modules from JSON..." + loadStart2 <- getCurrentTime + mods <- fmap concat $ CM.forM coderPackages loadPackageMain + loadEnd2 <- getCurrentTime + putStrLn $ " Loaded " ++ show (length mods) ++ " coder modules." + putStrLn $ " Time: " ++ formatTime (elapsed loadEnd2 loadStart2) + putStrLn "" + return mods + else do + putStrLn "Step 2: Skipping coder packages" + putStrLn "" + return [] + + -- Step 2b: Optionally load DSL wrapper modules from every loaded package. + -- Compute which non-baseline non-coder packages need to be loaded into + -- the universe. Each of hydra-rdf, hydra-coq, hydra-javascript, + -- hydra-ext, hydra-wasm is independent. hydra-pg depends on hydra-rdf + -- (e.g. hydra.pg.rdf.environment references hydra.rdf.syntax.Iri), so + -- loading hydra-pg implicitly loads hydra-rdf. + -- + -- --package

: load

+ its package-level deps when it's an ext + -- or ext-demo package + -- --ext-only : load both ext-demo packages (legacy demo path) + -- (otherwise) : nothing extra. --all-packages alone does NOT auto-load + -- these — sync-haskell.sh uses --all-packages to regen + -- only baseline + dsl artifacts; the per-package + -- assemble-distribution.sh handles coder/ext packages + -- individually with --package . + let allExtPackages = extPackages ++ extDemoPackages + let packageDeps p = case p of + "hydra-pg" -> ["hydra-pg", "hydra-rdf"] + _ -> [p] + let extPackagesToLoad + | optExtOnly opts = extDemoPackages + | Just p <- optPackage opts, p `elem` allExtPackages = packageDeps p + | otherwise = [] + + dslMods <- if optIncludeDsls opts + then do + putStrLn "Step 2b: Loading DSL wrapper modules from JSON..." + loadStart3 <- getCurrentTime + let dslPackages = + ["hydra-kernel", "hydra-haskell"] + ++ (if optIncludeCoders opts then coderPackages else []) + ++ extPackagesToLoad + mods <- fmap concat $ CM.forM dslPackages loadPackageDsl + loadEnd3 <- getCurrentTime + putStrLn $ " Loaded " ++ show (length mods) ++ " DSL modules." + putStrLn $ " Time: " ++ formatTime (elapsed loadEnd3 loadStart3) + putStrLn "" + return mods + else return [] + + -- Step 2c: Load main modules for any ext / ext-demo packages selected above. + -- Already-loaded namespaces (via --include-coders) are skipped to avoid + -- duplicates. + extMods <- if Prelude.null extPackagesToLoad + then return [] + else do + putStrLn "Step 2c: Loading ext package modules from JSON..." + loadStart4 <- getCurrentTime + allExtMods <- fmap concat $ CM.forM extPackagesToLoad loadPackageMain + let coderNsSet = fmap (unNamespace . moduleNamespace) (baselineMods ++ coderMods) + mods = Prelude.filter + (\m -> unNamespace (moduleNamespace m) `notElem` coderNsSet) + allExtMods + loadEnd4 <- getCurrentTime + putStrLn $ " Loaded " ++ show (length mods) ++ " ext modules." + putStrLn $ " Time: " ++ formatTime (elapsed loadEnd4 loadStart4) + putStrLn "" + return mods + + -- Apply filters + let allMods = baselineMods ++ coderMods ++ extMods ++ dslMods + let kernelNsStrings = fmap unNamespace allKernelNamespaces + let filtered1 = if optKernelOnly opts + then Prelude.filter (\m -> unNamespace (moduleNamespace m) `elem` kernelNsStrings) allMods + else allMods + let filtered2 = if optTypesOnly opts + then Prelude.filter (\m -> any isNativeType (moduleBindings m)) filtered1 + else filtered1 + let allMainMods = filtered2 + + when (optKernelOnly opts) $ do + putStrLn $ "Filtering to kernel modules: " ++ show (length allMainMods) ++ " of " ++ show (length allMods) + putStrLn "" + when (optTypesOnly opts) $ do + putStrLn $ "Filtering to type modules: " ++ show (length allMainMods) ++ " of " ++ show (length filtered1) + putStrLn "" + + -- Optionally synthesize decoder/encoder DSL source modules over the loaded + -- type modules, and add them to the modules-to-generate set. The + -- synthesized modules carry no type annotations, so we run inference over + -- them before handing them to the generator (which skips inference on the + -- loaded modules). + synthesizedSourceMods <- if optSynthesizeSources opts + then do + -- Decoder/encoder synthesis runs over a curated subset of loaded + -- type modules. Kernel type modules produce the Sources.Decode.* + -- and Sources.Encode.* coder-package meta-sources. hydra-pg's + -- model and mapping modules produce the pg meta-sources that were + -- historically generated by update-ext-sources. + let pgSynthNs = ["hydra.pg.model", "hydra.pg.mapping"] + -- Synth is meaningful only for namespaces the hydra-kernel manifest + -- claims, plus the two hydra-pg type modules (historical coverage + -- of update-ext-sources). Long-tail ext types (hydra.xml.schema, + -- hydra.avro.*, ...) produce synth output whose references can't + -- be resolved in the generator's lexical env during batch-mode + -- iteration. + let kernelNsList = fmap unNamespace allKernelNamespaces + let isSynthInput m = + let nsStr = unNamespace (moduleNamespace m) + isCoder = any (\(pfx, _) -> pfx `isPrefixOf` nsStr) packagePrefixes + isYaml = "hydra.yaml." `isPrefixOf` nsStr + isPgSynthInput = nsStr `elem` pgSynthNs + hasType = any isNativeType (moduleBindings m) + isKernel = (nsStr `elem` kernelNsList) && not isCoder && not isYaml + in hasType && (isKernel || isPgSynthInput) + let typeMods = Prelude.filter isSynthInput allMainMods + putStrLn $ "Synthesizing decoder/encoder source modules from " + ++ show (length typeMods) ++ " type modules..." + decSrc <- generateDecoderSourceModules allMainMods typeMods + encSrc <- generateEncoderSourceModules allMainMods typeMods + putStrLn $ " Synthesized " ++ show (length decSrc) ++ " decoder source modules" + putStrLn $ " Synthesized " ++ show (length encSrc) ++ " encoder source modules" + -- Run inference on the synthesized modules; the generator call below uses + -- doInfer=False, which would fail on these untyped bindings otherwise. + let synthesized = decSrc ++ encSrc + let inferUniverse = allMainMods ++ synthesized + inferred <- inferModulesIO inferUniverse synthesized + putStrLn $ " Inferred types for " ++ show (length inferred) ++ " synthesized modules" + putStrLn "" + return inferred + else return [] + + -- When --ext-only is used, load the ext demo packages (hydra-pg, hydra-rdf) + -- and generate only those, using allMainMods plus the loaded ext demo + -- modules as the universe for type resolution. + (modsToGenerate, allModsFinal) <- if optExtOnly opts + then do + putStrLn "Loading ext demo packages from JSON..." + extMods <- fmap concat $ CM.forM extDemoPackages loadPackageMain + -- Filter out any namespace already present in the baseline/coder set + -- so that downstream generation doesn't see duplicates. + let loadedNsSet = fmap (unNamespace . moduleNamespace) allMainMods + extMods' = Prelude.filter + (\m -> unNamespace (moduleNamespace m) `notElem` loadedNsSet) + extMods + putStrLn $ " Loaded " ++ show (length extMods') ++ " ext demo modules" + putStrLn "" + return (extMods', allMainMods ++ extMods') + else return (allMainMods, allMainMods) + + -- Layer 1 per-package scoping: if --package is set, narrow + -- modsToGenerate to modules owned by that package (per namespaceToPackage). + -- The universe (allModsFinal) is unchanged, so type references across + -- packages still resolve. Applies AFTER all other filters. + modsToGenerateScoped <- case optPackage opts of + Nothing -> return modsToGenerate + Just pkg -> do + let owned = Prelude.filter + (\m -> namespaceToPackage (moduleNamespace m) == pkg) + modsToGenerate + putStrLn $ "Scoping to package " ++ pkg ++ ": " + ++ show (length owned) ++ " of " ++ show (length modsToGenerate) ++ " modules" + putStrLn "" + return owned + + -- Stage 7: per-module checksum skip. For each module M whose DSL source + -- hash matches the hash recorded in the per-target digest at + -- //digest.json's inputs section, exclude M from + -- modsToGenerate. The output already on disk reflects exactly the same + -- DSL source content, so regeneration would produce a byte-identical + -- result. Excluding before generation skips inference work entirely. + -- + -- Only applied when --package is set (scoped mode). In unscoped mode + -- the per-module digest semantics get harder to reason about because + -- multiple packages share the same outBase tree. + -- Source set indicator: tests are generated when --include-tests is set + -- AND we're scoped to a single package. (In --all-packages mode, tests + -- are generated separately via testMods.) + let sourceSetForFilter = if optIncludeTests opts then "test" else "main" + + modsToGenerateScopedFiltered <- case optPackage opts of + Nothing -> return modsToGenerateScoped + Just pkg -> filterByTargetDigest outBase pkg sourceSetForFilter modsToGenerateScoped + + -- Prepend synthesized source modules to modsToGenerate (deduping by namespace + -- to keep ordering stable). They go into the same universe as the main modules. + let modsToGenerate' = modsToGenerateScopedFiltered ++ synthesizedSourceMods + let allModsFinal' = allModsFinal ++ synthesizedSourceMods + + -- Generate main modules + let stepNum = if optIncludeCoders opts then "3" else "2" + -- Stage 7: if every module was filtered out as fresh (and there's + -- no synthesis to do), this is a no-op. The downstream loop over + -- groupByPackage modsToGenerate' will naturally iterate zero times, + -- but we log it for clarity. + CM.when (Prelude.null modsToGenerate' && not (Prelude.null modsToGenerateScoped)) $ do + putStrLn $ "Step " ++ stepNum ++ ": all " + ++ show (length modsToGenerateScoped) ++ " main modules fresh; skipping generation." + + putStrLn $ "Step " ++ stepNum ++ ": Mapping " ++ show (length modsToGenerate') ++ " modules to " ++ targetCap ++ "..." + + genStart <- getCurrentTime + let lispDialectAndExt = case target of + "clojure" -> Just (LispSyntax.DialectClojure, "clj") + "scheme" -> Just (LispSyntax.DialectScheme, "scm") + "common-lisp" -> Just (LispSyntax.DialectCommonLisp, "lisp") + "emacs-lisp" -> Just (LispSyntax.DialectEmacsLisp, "el") + _ -> Nothing + + let lispGenerator = case lispDialectAndExt of + Just (dialect, lispExt) -> Just (moduleToLispDialect dialect lispExt) + Nothing -> Nothing + + -- 'mods' is the set this scoped package wants written. The full + -- universe is passed for typing context only; generateSourceFiles + -- emits files only for the modsToGenerate argument (per the existing + -- typeModulesToGenerate / termModulesToGenerate filters in + -- Hydra.Codegen). No expansion, no prune. + let genForDir :: FilePath -> [Module] -> IO Int + genForDir dir mods = case target of + "haskell" -> generateSources moduleToHaskell haskellLanguage False False False False dir allModsFinal' mods + "java" -> generateSources moduleToJava javaLanguage False True False True dir allModsFinal' mods + "python" -> generateSources moduleToPython pythonLanguage False True True False dir allModsFinal' mods + "scala" -> generateSources moduleToScala scalaLanguage False True False False dir allModsFinal' mods + _ | Just g <- lispGenerator -> + generateSources g lispLanguage True False False False dir allModsFinal' mods + _ -> do + putStrLn $ "Unknown target: " ++ target + exitFailure + + -- Partition modules by owning package and generate each group to its own dir. + -- Routing via PackageRouting.groupByPackage is unconditional: every module + -- lands at //src/main//... based on its namespace. + -- + -- Three routing modes: + -- --package : one package, per-package dir (scoped sync path) + -- --all-packages : every package, per-package dirs (batch sync path) + -- (neither) : flat /src/main// (demo path) + mainFileCount <- case (optPackage opts, optAllPackages opts) of + (Just pkgArg, _) -> do + let groups = groupByPackage modsToGenerate' + let scopedGroups = Prelude.filter (\(pkg, _) -> pkg == pkgArg) groups + counts <- CM.forM scopedGroups $ \(pkg, pkgMods) -> do + let dir = packageOutMain pkg + putStrLn $ " " ++ pkg ++ ": " ++ show (length pkgMods) ++ " modules → " ++ dir + genForDir dir pkgMods + return (sum counts) + (Nothing, True) -> do + let groups = groupByPackage modsToGenerate' + counts <- CM.forM groups $ \(pkg, pkgMods) -> do + let dir = packageOutMain pkg + putStrLn $ " " ++ pkg ++ ": " ++ show (length pkgMods) ++ " modules → " ++ dir + genForDir dir pkgMods + return (sum counts) + (Nothing, False) -> do + putStrLn $ " " ++ show (length modsToGenerate') ++ " modules → " ++ outMain + genForDir outMain modsToGenerate' + genEnd <- getCurrentTime + + putStrLn $ " Generated " ++ show mainFileCount ++ " files." + putStrLn $ " Time: " ++ formatTime (elapsed genEnd genStart) + putStrLn "" + + -- Optionally generate test modules + testFileCount <- if optIncludeTests opts + then do + putStrLn "Loading test modules from JSON..." + testNamespaces <- readManifestField kernelJsonDir "testModules" + testModsAll <- loadModulesFromJson testJsonDir kernelModules testNamespaces + putStrLn $ " Loaded " ++ show (length testModsAll) ++ " test modules" + + -- Layer 1 per-package scoping for tests: if --package is set, + -- narrow testMods to modules owned by that package. The universe is + -- unchanged so cross-package refs still resolve. + -- + -- Additionally, filter out skip-emit namespaces (e.g. hydra.test.testEnv). + -- These are type-only stubs whose hand-written per-language + -- counterparts are the source of truth; emitting them would + -- overwrite hand-written code. + let notSkipEmit m = moduleNamespace m `notElem` testSkipEmitNamespaces + let testMods = Prelude.filter notSkipEmit $ case optPackage opts of + Nothing -> testModsAll + Just pkg -> + Prelude.filter + (\m -> namespaceToPackage (moduleNamespace m) == pkg) + testModsAll + case optPackage opts of + Just pkg | length testMods /= length testModsAll -> + putStrLn $ " Scoping to package " ++ pkg ++ ": " + ++ show (length testMods) ++ " of " ++ show (length testModsAll) ++ " test modules" + _ -> return () + putStrLn "" + + let allUniverse = allMods ++ testModsAll + + -- When --kernel-only is active, non-kernel modules are excluded from allMainMods. + -- But test modules may depend on non-kernel modules (e.g. hydra.test.serialization + -- depends on hydra.haskell.operators). Generate those modules to outMain + -- so test code can reference them. + when (optKernelOnly opts) $ do + let testExtraDeps = Prelude.filter (\ns -> unNamespace ns `notElem` kernelNsStrings) + $ concatMap moduleTermDependencies testMods + extModsForTests = Prelude.filter (\m -> moduleNamespace m `elem` testExtraDeps) allMods + when (not (Prelude.null extModsForTests)) $ do + putStrLn $ "Generating " ++ show (length extModsForTests) ++ " ext module(s) needed by tests..." + case target of + "haskell" -> generateSources moduleToHaskell haskellLanguage False False False False outMain allUniverse extModsForTests >> return () + "java" -> generateSources moduleToJava javaLanguage False True False True outMain allUniverse extModsForTests >> return () + "python" -> generateSources moduleToPython pythonLanguage False True True False outMain allUniverse extModsForTests >> return () + _ | Just gen <- lispGenerator -> generateSources gen lispLanguage False False False False outMain allUniverse extModsForTests >> return () + _ -> return () + putStrLn "" + + putStrLn $ "Mapping test modules to " ++ targetCap ++ "..." + + -- Dispatch helper for the test source set. + let genTestForDir :: FilePath -> [Module] -> IO Int + genTestForDir dir mods = case target of + "haskell" -> generateSources moduleToHaskell haskellLanguage False False False False dir allUniverse mods + "java" -> generateSources moduleToJava javaLanguage False True False True dir allUniverse mods + "python" -> generateSources moduleToPython pythonLanguage False True True False dir allUniverse mods + "scala" -> generateSources moduleToScala scalaLanguage False True False False dir allUniverse mods + _ | Just gen <- lispGenerator -> generateSources gen lispLanguage False False False False dir allUniverse mods + _ -> return 0 + + testStart <- getCurrentTime + count <- case (optPackage opts, optAllPackages opts) of + (Just pkgArg, _) -> do + let groups = groupByPackage testMods + let scopedGroups = Prelude.filter (\(pkg, _) -> pkg == pkgArg) groups + counts <- CM.forM scopedGroups $ \(pkg, pkgMods) -> do + let dir = packageOutTest pkg + putStrLn $ " " ++ pkg ++ ": " ++ show (length pkgMods) ++ " test modules → " ++ dir + genTestForDir dir pkgMods + return (sum counts) + (Nothing, True) -> do + let groups = groupByPackage testMods + counts <- CM.forM groups $ \(pkg, pkgMods) -> do + let dir = packageOutTest pkg + putStrLn $ " " ++ pkg ++ ": " ++ show (length pkgMods) ++ " test modules → " ++ dir + genTestForDir dir pkgMods + return (sum counts) + (Nothing, False) -> do + putStrLn $ " " ++ show (length testMods) ++ " test modules → " ++ outTest + genTestForDir outTest testMods + testEnd <- getCurrentTime + + putStrLn $ " Generated " ++ show count ++ " test files." + putStrLn $ " Time: " ++ formatTime (elapsed testEnd testStart) + putStrLn "" + return count + else return 0 + + let genTestSuccess = True + + -- Scala post-processing: wrap long lines in every generated .scala file. + -- The Scala compiler hits stack/memory limits on extremely long single-line + -- expressions; wrapping is the same pass that writeScala applies in the + -- DSL-direct path, lifted here so the JSON pipeline produces identical output. + when (target == "scala") $ do + putStrLn "Post-processing: wrapping long Scala lines..." + wrapLongLinesInScalaTree outBase + putStrLn "" + + putStrLn "==========================================" + putStrLn $ "Done: " ++ show mainFileCount ++ " main" + ++ (if optIncludeTests opts then " + " ++ show testFileCount ++ " test" else "") + ++ " files" + putStrLn $ " Output: " ++ outBase + putStrLn "==========================================" + + if not genTestSuccess + then exitFailure + else return () + +elapsed :: UTCTime -> UTCTime -> Double +elapsed end start = realToFrac (diffUTCTime end start) + +-- | Stage 7: per-module target-side freshness filter. +-- +-- For each module M in the input set, check whether its current DSL +-- source hash matches the hash recorded in the per-target digest +-- (//digest.json's "inputs" section). If so, the +-- target output already on disk reflects exactly the same DSL content, +-- so M can be skipped (no inference, no generation, no write). +-- +-- The recorded digest is in v2 format (digest-check refresh writes it +-- after a successful regen). The "inputs" map's keys are namespace +-- strings (e.g. "hydra.core"); values are SHA-256 hex of the DSL +-- source file as of the last successful regen. +-- +-- Modules with no recorded entry are kept (treated as dirty). +-- Modules with no current DSL source (synth modules etc.) are also +-- kept — we can't verify staleness, so we don't risk a false skip. +-- +-- The per-target digest is read from +-- //src//digest.json, where outBase is e.g. +-- "../../dist/java" (the parent of the per-package target dirs) and +-- sourceSet is "main" or "test". +filterByTargetDigest :: FilePath -> String -> String -> [Module] -> IO [Module] +filterByTargetDigest outBase pkg sourceSet mods = do + let digestPath = outBase FP. pkg FP. "src" FP. sourceSet FP. "digest.json" + exists <- SD.doesFileExist digestPath + if not exists + then do + putStrLn $ " Per-module skip: no target digest at " ++ digestPath + ++ "; keeping all " ++ show (length mods) ++ " modules" + return mods + else do + stored <- Digest.readDigestV2 digestPath + let recordedInputs = Digest.digestInputs stored + if M.null recordedInputs + then do + putStrLn $ " Per-module skip: target digest empty; keeping all " + ++ show (length mods) ++ " modules" + return mods + else do + -- Compute current DSL source hashes. + nsFiles <- Digest.discoverNamespaceFiles + currentDigest <- Digest.hashUniverse nsFiles mods + let isFresh m = + let nsStr = unNamespace (moduleNamespace m) + in case (M.lookup nsStr recordedInputs, M.lookup (Namespace nsStr) currentDigest) of + (Just rec, Just cur) -> Digest.entryHash rec == cur + _ -> False + (fresh, dirty) = partition isFresh mods + if Prelude.null fresh + then do + putStrLn $ " Per-module skip: 0 fresh / " + ++ show (length dirty) ++ " dirty; processing all" + return mods + else if Prelude.null dirty + then do + putStrLn $ " Per-module skip: " ++ show (length fresh) + ++ " fresh / 0 dirty; nothing to generate" + return [] + else do + putStrLn $ " Per-module skip: " ++ show (length fresh) + ++ " fresh / " ++ show (length dirty) + ++ " dirty; excluding fresh from generation" + return dirty + diff --git a/src/exec/diag-module/Main.hs b/src/exec/diag-module/Main.hs new file mode 100644 --- /dev/null +++ b/src/exec/diag-module/Main.hs @@ -0,0 +1,200 @@ +-- Diagnostic: bisect the incremental-inference bug down to individual +-- definitions. +-- +-- Modes: +-- stack exec diag-module -- +-- Use full modules as the dirty set; load the rest from dist/json. +-- +-- stack exec diag-module -- --subset +-- Build a synthetic module containing only the named definitions +-- of , use that as the single dirty module, load the rest of +-- the universe (including the full version of ) from dist/json. +-- This lets us narrow the failure to a specific definition. +-- +-- stack exec diag-module -- --list-defs +-- Print the definition names of the module, one per line. +module Main where + +import Hydra.Kernel +import Hydra.Generation (inferModulesGivenIO) +import qualified Hydra.Codegen as CodeGeneration +import qualified Hydra.Sources.All as All +import qualified Hydra.Sources.Ext as Ext +import qualified Hydra.Show.Errors as ShowError +import qualified Hydra.Json.Model as JsonModel +import Hydra.Dsl.Bootstrap (bootstrapGraph) +import qualified Hydra.PackageRouting as PackageRouting + +import qualified Data.Aeson as A +import qualified Data.ByteString.Lazy as BS +import qualified Data.Aeson.KeyMap as AKM +import qualified Data.Aeson.Key as AK +import qualified Data.Vector as V +import qualified Data.Text as T + +import qualified Data.Map as M +import qualified Data.List as L +import qualified Control.Exception as E +import qualified Control.Monad as CM +import qualified System.Environment as Env +import qualified System.FilePath as FP +import qualified System.Directory as SD +import System.IO (hSetBuffering, stdout, BufferMode(..)) + +parseJsonFile :: FilePath -> IO (Either String JsonModel.Value) +parseJsonFile path = do + bytes <- BS.readFile path + case A.eitherDecode bytes of + Left err -> return (Left err) + Right aesonVal -> return (Right (aesonToJsonModel aesonVal)) + +aesonToJsonModel :: A.Value -> JsonModel.Value +aesonToJsonModel v = case v of + A.Null -> JsonModel.ValueNull + A.Bool b -> JsonModel.ValueBoolean b + A.Number n -> JsonModel.ValueNumber n + A.String t -> JsonModel.ValueString (T.unpack t) + A.Array xs -> JsonModel.ValueArray (fmap aesonToJsonModel (V.toList xs)) + A.Object o -> JsonModel.ValueObject (M.fromList [(T.unpack (AK.toText k), aesonToJsonModel x) | (k, x) <- AKM.toList o]) + +loadModuleFromJson :: FilePath -> [Module] -> Namespace -> IO Module +loadModuleFromJson distJsonRoot universe ns = do + let pkg = PackageRouting.namespaceToPackage ns + pkgDir = distJsonRoot FP. pkg FP. "src" FP. "main" FP. "json" + filePath = pkgDir FP. CodeGeneration.namespaceToPath ns ++ ".json" + parseResult <- parseJsonFile filePath + case parseResult of + Left err -> fail $ "JSON parse error for " ++ unNamespace ns ++ " at " ++ filePath ++ ": " ++ err + Right jsonVal -> case CodeGeneration.decodeModuleFromJson bootstrapGraph universe jsonVal of + Left err -> fail $ "Module decode error for " ++ unNamespace ns ++ ": " ++ ShowError.error err + Right m -> return m + +main :: IO () +main = do + hSetBuffering stdout NoBuffering + args <- Env.getArgs + case args of + ["--list-defs", ns] -> listDefs ns + ["--subset", ns, defSpec] -> runSubset ns defSpec + [spec] -> runModules spec + _ -> fail "Usage: diag-module [--list-defs ] [--subset ] []" + +listDefs :: String -> IO () +listDefs nsStr = do + let ns = Namespace nsStr + universe = All.mainModules ++ Ext.hydraExtModules + case L.find (\m -> moduleNamespace m == ns) universe of + Nothing -> fail $ "No such module: " ++ nsStr + Just m -> do + let defs = moduleDefinitions m + putStrLn $ "Definitions in " ++ nsStr ++ " (" ++ show (length defs) ++ " total):" + mapM_ putStrLn (definitionNames defs) + +definitionNames :: [Definition] -> [String] +definitionNames ds = fmap definitionName ds + where + definitionName d = case d of + DefinitionTerm td -> unName (termDefinitionName td) + DefinitionType td -> unName (typeDefinitionName td) + +runModules :: String -> IO () +runModules spec = do + let universe = All.mainModules ++ Ext.hydraExtModules + putStrLn $ "Universe: " ++ show (length universe) ++ " modules" + let allKernelNss = [moduleNamespace m | m <- universe, + let ns = unNamespace (moduleNamespace m), + not ("hydra.test." `L.isPrefixOf` ns), + not ("hydra.ext." `L.isPrefixOf` ns), + not ("hydra.wasm." `L.isPrefixOf` ns), + not ("hydra.coq." `L.isPrefixOf` ns), + not ("hydra.javascript." `L.isPrefixOf` ns)] + half = length allKernelNss `div` 2 + dirtyNss = case spec of + "ALL" -> allKernelNss + "HALF1" -> take half allKernelNss + "HALF2" -> drop half allKernelNss + _ -> fmap Namespace (splitCommas spec) + putStrLn $ "Dirty set: " ++ show (length dirtyNss) ++ " modules" + CM.when (length dirtyNss <= 20) $ + mapM_ (\ns -> putStrLn $ " " ++ unNamespace ns) dirtyNss + let dirtySet = M.fromList [(ns, ()) | ns <- dirtyNss] + dirtyMods = [m | m <- universe, M.member (moduleNamespace m) dirtySet] + cleanMods = [m | m <- universe, not (M.member (moduleNamespace m) dirtySet)] + runWithCleanAndDirty cleanMods dirtyMods + +-- Subset mode: build a dirty module at namespace "hydra.bisect" that +-- contains CLONES of the named definitions from . The full stays +-- in the clean universe, so cross-definition references in the clones +-- resolve against it (i.e. clone of X calling Y sees clean X.Y). The +-- cloned definition names are `hydra.bisect.`, so there's +-- no name collision with the clean universe. +-- +-- This isolates whether a specific definition's term body / type +-- annotation triggers the unification bug, without perturbing the rest +-- of the universe. +runSubset :: String -> String -> IO () +runSubset nsStr defSpec = do + let ns = Namespace nsStr + universe = All.mainModules ++ Ext.hydraExtModules + wanted = splitCommas defSpec + bisectNs = Namespace "hydra.bisect" + case L.find (\m -> moduleNamespace m == ns) universe of + Nothing -> fail $ "No such module: " ++ nsStr + Just fullMod -> do + let allDefs = moduleDefinitions fullMod + lastCompOf s = L.reverse (L.takeWhile (/= '.') (L.reverse s)) + defMatches n d = case d of + DefinitionTerm td -> lastCompOf (unName (termDefinitionName td)) == n + DefinitionType td -> lastCompOf (unName (typeDefinitionName td)) == n + picked = [d | n <- wanted, d <- allDefs, defMatches n d] + let defName d = case d of + DefinitionTerm td -> unName (termDefinitionName td) + DefinitionType td -> unName (typeDefinitionName td) + CM.when (length picked /= length wanted) $ do + putStrLn "Warning: not all requested definitions were found." + let found = fmap defName picked + missing = filter (\n -> not (elem n found)) wanted + mapM_ (\m -> putStrLn $ " missing: " ++ m) missing + let cloneDef d = case d of + DefinitionTerm td -> + DefinitionTerm td { termDefinitionName = rename (termDefinitionName td) } + DefinitionType td -> + DefinitionType td { typeDefinitionName = rename (typeDefinitionName td) } + rename (Name full) = + let simple = L.reverse (L.takeWhile (/= '.') (L.reverse full)) + in Name ("hydra.bisect." ++ simple) + cloned = fmap cloneDef picked + let syntheticDirty = Module { + moduleNamespace = bisectNs, + moduleDefinitions = cloned, + moduleTermDependencies = [ns], + moduleTypeDependencies = [ns], + moduleDescription = Just "Bisection dummy module" } + putStrLn $ "Universe: " ++ show (length universe) ++ " kept intact; dirty is new hydra.bisect with " ++ show (length picked) ++ " cloned defs:" + mapM_ (\d -> putStrLn $ " " ++ defName d ++ " → " ++ cloneName d) picked + runWithCleanAndDirty universe [syntheticDirty] + where + cloneName d = case d of + DefinitionTerm td -> "hydra.bisect." ++ lastComp (unName (termDefinitionName td)) + DefinitionType td -> "hydra.bisect." ++ lastComp (unName (typeDefinitionName td)) + lastComp s = L.reverse (L.takeWhile (/= '.') (L.reverse s)) + +runWithCleanAndDirty :: [Module] -> [Module] -> IO () +runWithCleanAndDirty cleanMods dirtyMods = do + putStrLn $ "Loading " ++ show (length cleanMods) ++ " clean modules from dist/json..." + distJsonRoot <- SD.makeAbsolute "../../dist/json" + cleanLoaded <- mapM (loadModuleFromJson distJsonRoot (cleanMods ++ dirtyMods) . moduleNamespace) cleanMods + putStrLn "Running inferModulesGiven..." + result <- E.try (inferModulesGivenIO (cleanLoaded ++ dirtyMods) dirtyMods) :: IO (Either E.SomeException [Module]) + case result of + Left e -> do + putStrLn "FAILED" + putStrLn $ show e + Right _ -> putStrLn "OK" + +splitCommas :: String -> [String] +splitCommas [] = [] +splitCommas s = let (h, t) = break (== ',') s + in h : case t of + [] -> [] + _ -> splitCommas (drop 1 t) diff --git a/src/exec/digest-check/Main.hs b/src/exec/digest-check/Main.hs new file mode 100644 --- /dev/null +++ b/src/exec/digest-check/Main.hs @@ -0,0 +1,238 @@ +-- | Per-target freshness check + digest refresh tool. +-- +-- Two subcommands: +-- +-- digest-check fresh --inputs --output-digest +-- Reads the input digest (e.g. dist/json//digest.json) and +-- the output digest (e.g. dist///digest.json). +-- Returns exit 0 if: +-- * the inputs section of the output digest matches the input +-- digest's hashes, +-- * every output file recorded in the output digest exists and +-- hashes to its recorded value, +-- * the generator stamp matches the current generator stamp. +-- Returns exit 1 (cache miss) otherwise. +-- +-- Callers use this with an `if !` shell idiom to skip work when +-- fresh and run the work otherwise. +-- +-- digest-check refresh --inputs --output-dir

+-- --output-digest +-- Recomputes the hash of every regular file under (recursive), +-- reads the input digest, and writes a new output digest with both +-- sections populated plus the current generator stamp. +-- +-- Run after a successful regen to record what was produced. +-- +-- All paths are taken as-is (no implicit normalization). + +module Main where + +import Hydra.Digest +import Hydra.Packaging (Namespace(..)) + +import Control.Monad (when, forM) +import Data.List (isPrefixOf) +import qualified Data.Map as M +import System.Directory (doesDirectoryExist, doesFileExist, listDirectory) +import System.Environment (getArgs) +import System.Exit (exitFailure, exitSuccess) +import qualified System.FilePath as FP +import System.IO (hPutStrLn, stderr) + +data Mode = Fresh | Refresh deriving (Eq, Show) + +data Options = Options + { optMode :: Mode + , optInputDigest :: FilePath + , optOutputDigest :: FilePath + , optOutputDir :: Maybe FilePath + } deriving Show + +usage :: String +usage = unlines + [ "Usage:" + , " digest-check fresh --inputs --output-dir --output-digest " + , " digest-check refresh --inputs --output-dir --output-digest " + , "" + , " fresh: exit 0 if cache hit (skip work), exit 1 if miss (do work)." + , " Resolves recorded (relative) output paths against ." + , " refresh: walk , hash every file, write a new" + , " with paths stored relative to ." + ] + +parseArgs :: [String] -> Either String Options +parseArgs [] = Left "Missing subcommand" +parseArgs (cmd : rest) = do + mode <- case cmd of + "fresh" -> Right Fresh + "refresh" -> Right Refresh + _ -> Left ("Unknown subcommand: " ++ cmd) + go (Options mode "" "" Nothing) rest + where + go opts [] = if null (optInputDigest opts) || null (optOutputDigest opts) + then Left "Missing required --inputs or --output-digest" + else if optOutputDir opts == Nothing + then Left "--output-dir is required" + else Right opts + go opts ("--inputs" : v : xs) = go (opts { optInputDigest = v }) xs + go opts ("--output-digest" : v : xs) = go (opts { optOutputDigest = v }) xs + go opts ("--output-dir" : v : xs) = go (opts { optOutputDir = Just v }) xs + go _ (a : _) = Left ("Unknown argument: " ++ a) + +main :: IO () +main = do + args <- getArgs + case parseArgs args of + Left err -> do + hPutStrLn stderr ("Error: " ++ err) + hPutStrLn stderr usage + exitFailure + Right opts -> case optMode opts of + Fresh -> doFresh opts + Refresh -> doRefresh opts + +doFresh :: Options -> IO () +doFresh opts = do + -- Input digest: must exist. Absent means we have no record of what + -- was used, so always treat as cache miss. + inputExists <- doesFileExist (optInputDigest opts) + if not inputExists + then do + putStrLn $ " digest-check: input digest absent (" + ++ optInputDigest opts ++ "); cache miss" + exitFailure + else return () + + -- Output digest: must exist. Absent means we have no record of + -- what was produced previously. + outputExists <- doesFileExist (optOutputDigest opts) + if not outputExists + then do + putStrLn $ " digest-check: output digest absent (" + ++ optOutputDigest opts ++ "); cache miss" + exitFailure + else return () + + inputDigest <- Hydra.Digest.readDigest (optInputDigest opts) + outputDigest <- Hydra.Digest.readDigestV2 (optOutputDigest opts) + + -- Compare: each input hash from the v1 input digest must appear, + -- with the same hash, in the v2 output digest's inputs map. (We + -- key by namespace string in v1; in v2 we use FilePath. The bridge + -- is namespace strings live as paths in the output digest, recorded + -- by 'refresh' below.) + let recordedInputs = M.map entryHash (digestInputs outputDigest) + currentInputs = M.fromList + [ (k, v) | (Namespace k, v) <- M.toList inputDigest ] + + if recordedInputs /= currentInputs + then do + putStrLn $ " digest-check: input mismatch; cache miss" + exitFailure + else return () + + -- Generator stamp must match. + currentGen <- generatorStamp + if currentGen /= digestGenerator outputDigest + then do + putStrLn $ " digest-check: generator stamp mismatch (" + ++ digestGenerator outputDigest ++ " vs " ++ currentGen + ++ "); cache miss" + exitFailure + else return () + + -- Output files must all exist with matching hashes. Paths recorded + -- in the digest are relative to outputDir (per 'refresh' below). + let outputDir = case optOutputDir opts of + Just d -> d + Nothing -> error "doFresh called without output-dir (parseArgs bug)" + outputsOk <- fmap and $ forM (M.toList (digestOutputs outputDigest)) $ \(rel, entry) -> do + let abs_ = outputDir FP. rel + exists <- doesFileExist abs_ + if not exists then return False else do + h <- Hydra.Digest.hashFile abs_ + return (h == entryHash entry) + if not outputsOk + then do + putStrLn $ " digest-check: output files missing or modified; cache miss" + exitFailure + else do + putStrLn $ " digest-check: cache hit; skipping work" + exitSuccess + +doRefresh :: Options -> IO () +doRefresh opts = do + let outputDir = case optOutputDir opts of + Just d -> d + Nothing -> error "doRefresh called without output-dir (parseArgs bug)" + -- Read the input digest. May be absent if the inputs themselves + -- aren't cached yet; that's OK, we'll just record an empty inputs + -- map and the next 'fresh' check will miss until inputs settle. + inputDigest <- Hydra.Digest.readDigest (optInputDigest opts) + let inputsAsMap = M.fromList + [ (k, DigestEntry KindOther v) + | (Namespace k, v) <- M.toList inputDigest + ] + + -- Walk the output dir. Paths are stored relative to outputDir for + -- portability (absolute paths would bake in the worktree location + -- and break across machines, CI runners, etc). + -- + -- Exclude the output-digest file itself from the walk: we're about + -- to overwrite it, and hashing it here would (a) be a self-reference + -- that changes every run and (b) race with writeDigestV2 below. + allFiles <- listFilesRecursive outputDir + -- Normalize both sides so "dir//digest.json" (double slash from a + -- pkg_dir with trailing /) compares equal to "dir/digest.json" as + -- emitted by listFilesRecursive. + let digestPath = FP.normalise (optOutputDigest opts) + files = filter (\fp -> FP.normalise fp /= digestPath) allFiles + outputs <- fmap M.fromList $ forM files $ \fp -> do + h <- Hydra.Digest.hashFile fp + let rel = makeRelative' outputDir fp + return (rel, DigestEntry KindTargetFile h) + + gen <- generatorStamp + + let d = Digest + { digestInputs = inputsAsMap + , digestOutputs = outputs + , digestGenerator = gen + } + + Hydra.Digest.writeDigestV2 (optOutputDigest opts) d + putStrLn $ " digest-check: wrote " ++ optOutputDigest opts + ++ " (" ++ show (M.size inputsAsMap) ++ " inputs, " + ++ show (M.size outputs) ++ " outputs)" + +-- | Recursively list every regular file under a directory. +-- Skips dotfiles and dot-directories. +listFilesRecursive :: FilePath -> IO [FilePath] +listFilesRecursive root = do + exists <- doesDirectoryExist root + if not exists then return [] else go root + where + go dir = do + entries <- listDirectory dir + fmap concat $ forM entries $ \e -> + if "." `isPrefixOf` e + then return [] + else do + let p = dir FP. e + isDir <- doesDirectoryExist p + if isDir + then go p + else do + isFile <- doesFileExist p + return (if isFile then [p] else []) + +-- | Compute 'path' relative to 'base'. If 'path' isn't under 'base', +-- returns 'path' unchanged (callers should guard against that, but the +-- fallback keeps us from producing absolute paths accidentally). +makeRelative' :: FilePath -> FilePath -> FilePath +makeRelative' base path = + let prefix = if not (null base) && last base == '/' then base else base ++ "/" + in if prefix `isPrefixOf` path + then drop (length prefix) path + else path diff --git a/src/exec/generate-coq-tests/Main.hs b/src/exec/generate-coq-tests/Main.hs new file mode 100644 --- /dev/null +++ b/src/exec/generate-coq-tests/Main.hs @@ -0,0 +1,44 @@ +module Main where + +import Hydra.Sources.All (kernelModules, mainModules) +import Hydra.Sources.Test.All (testModules) +import Hydra.ExtGeneration (writeCoq) + +import Control.Monad (forM_) +import Data.List (sort) +import System.Directory (copyFile, createDirectoryIfMissing, doesDirectoryExist, listDirectory) +import System.FilePath (()) + +-- | Copy hand-written test-support .v files (e.g. runner.v) into the +-- generated test tree so coqc can see them alongside the generated modules. +-- Source path is resolved relative to the current working directory, which +-- is heads/haskell/ when generate-coq-tests runs. +copyCoqTestFiles :: FilePath -> IO () +copyCoqTestFiles baseDir = do + let srcDir = "src/test/coq" "hydra" "test" + dstDir = baseDir "hydra" "test" + srcExists <- doesDirectoryExist srcDir + if not srcExists + then return () + else do + createDirectoryIfMissing True dstDir + files <- sort <$> listDirectory srcDir + forM_ files $ \f -> do + copyFile (srcDir f) (dstDir f) + putStrLn (" hydra/test/" ++ f) + +main :: IO () +main = do + let outputDir = "../../dist/coq/hydra-kernel/src/test/coq" + universe = mainModules ++ testModules + putStrLn "Generating Coq (.v) files from Hydra test modules..." + n <- writeCoq outputDir universe testModules + putStrLn $ "Generated " ++ show n ++ " test .v files" + putStrLn "Copying hand-written test support files..." + copyCoqTestFiles outputDir + -- Kernel modules are in dist/coq/hydra-kernel/src/main/coq. The generated + -- test files Require their dependencies via fully qualified `hydra.*` + -- module paths, so both roots need to be on coqc's library path. See the + -- _CoqProject in the test runner directory (written separately). + putStrLn $ "Output: " ++ outputDir + putStrLn $ "(Add a _CoqProject that unions the main and test trees to coqc.)" diff --git a/src/exec/generate-coq/Main.hs b/src/exec/generate-coq/Main.hs new file mode 100644 --- /dev/null +++ b/src/exec/generate-coq/Main.hs @@ -0,0 +1,14 @@ +module Main where + +import Hydra.Sources.All (kernelModules) +import Hydra.ExtGeneration (writeCoq) +import Hydra.Coq.GenerateDriver (writeCoqProject, copyCoqLibFiles) + +main :: IO () +main = do + let outputDir = "../../dist/coq/hydra-kernel/src/main/coq" + putStrLn "Generating Coq (.v) files from Hydra kernel modules..." + writeCoqProject outputDir + copyCoqLibFiles outputDir + n <- writeCoq outputDir kernelModules kernelModules + putStrLn $ "Generated " ++ show n ++ " .v files" diff --git a/src/exec/transform-haskell-dsl-to-json/Main.hs b/src/exec/transform-haskell-dsl-to-json/Main.hs new file mode 100644 --- /dev/null +++ b/src/exec/transform-haskell-dsl-to-json/Main.hs @@ -0,0 +1,269 @@ +-- | Layer 1 transform: Haskell DSL -> JSON, scoped to a single package and +-- source set. +-- +-- Usage: +-- transform-haskell-dsl-to-json --package --source-set +-- [--dist-json-root ] +-- +-- Reads the named package's manifest module (via Hydra.Sources.Ext, which +-- re-exports every per-package manifest), selects the requested source set, +-- and writes that set's JSON under //src//json/. +-- +-- The full main-side universe (all packages) is used as the type-resolution +-- context, so cross-package type references resolve correctly. Only the +-- requested package's modules are actually written to disk. +-- +-- Empty source sets (e.g. 'test' on a package with no test modules) exit 0 +-- cleanly with a one-line note; callers can invoke unconditionally. +-- +-- This is a Layer 1 transform per the sync system design in +-- feature_290_packaging-plan.md: stateless, idempotent, single +-- (package, source-set) pair per invocation. Composition is the orchestrator's +-- job, not this exec's. + +module Main where + +import Hydra.Generation (writeModulesJson, writeModulesJsonPackageSplit, writeDslJsonPackageSplit) +import Hydra.PackageRouting (defaultDistJsonRoot, namespaceToPackage) +import Hydra.Sources.Ext ( + mainModules, dslSourceModules, + kernelModules, haskellModules, jsonModules, otherModules, + hydraCoqModules, hydraJavaModules, hydraJavaScriptModules, + hydraPythonModules, hydraScalaModules, hydraLispModules, + hydraPgModules, hydraRdfModules, hydraWasmModules, + hydraExtPackageModules, + hydraExtDecodingModules, hydraExtEncodingModules) +import Hydra.Sources.Eval.Lib.All (evalLibModules) +import Hydra.Sources.Test.All (testModules) + +import qualified Hydra.Kernel as Kernel +import qualified Hydra.Sources.Demos.GenPG.Transform as GenPGTransform + +import Control.Monad (when) +import qualified Data.List as L +import qualified Data.Set as S +import System.Environment (getArgs) +import System.Exit (exitFailure, exitSuccess) +import qualified System.FilePath as FP + + +-- | Deduplicate a list of modules by namespace, keeping the first occurrence. +dedupByNamespace :: [Kernel.Module] -> [Kernel.Module] +dedupByNamespace = go S.empty + where + go _ [] = [] + go seen (m:ms) + | ns `S.member` seen = go seen ms + | otherwise = m : go (S.insert ns seen) ms + where ns = Kernel.moduleNamespace m + + +-- | All main-side modules across all packages, deduped. Used as the type- +-- resolution universe regardless of which package is being written. +-- +-- Every package's DSL sources are included here so that per-package JSON +-- output can route modules to their owning package via namespaceToPackage. +fullMainUniverse :: [Kernel.Module] +fullMainUniverse = dedupByNamespace $ L.concat + [ mainModules + , evalLibModules + , dslSourceModules + , hydraCoqModules + , hydraJavaModules + , hydraJavaScriptModules + , hydraPythonModules + , hydraScalaModules + , hydraLispModules + , hydraPgModules + , hydraRdfModules + , hydraWasmModules + , hydraExtPackageModules + , hydraExtDecodingModules + , hydraExtEncodingModules + , [GenPGTransform.module_] + ] + + +data Options = Options + { optPackage :: Maybe String + , optSourceSet :: String + , optDistJsonRoot :: FilePath + } + +defaultOptions :: Options +defaultOptions = Options + { optPackage = Nothing + , optSourceSet = "main" + , optDistJsonRoot = defaultDistJsonRoot + } + + +parseArgs :: [String] -> Either String Options +parseArgs = go defaultOptions + where + go opts [] = case optPackage opts of + Nothing -> Right opts -- no --package means "all packages" (batch mode) + Just _ -> Right opts + go opts ("--package" : p : rest) = go (opts { optPackage = Just p }) rest + go opts ("--all" : rest) = go (opts { optPackage = Nothing }) rest + go opts ("--source-set" : s : rest) + | s == "main" || s == "test" = go (opts { optSourceSet = s }) rest + | otherwise = Left $ "--source-set must be 'main' or 'test', got: " ++ s + go opts ("--dist-json-root" : d : rest) = go (opts { optDistJsonRoot = d }) rest + go _ (arg : _) = Left $ "Unknown argument: " ++ arg + + +usage :: String +usage = unlines + [ "Usage: transform-haskell-dsl-to-json [--package ] [OPTIONS]" + , "" + , "Options:" + , " --package Package to transform. If omitted (or --all" + , " is passed), every package is transformed in a" + , " single Haskell-universe load." + , " Packages: hydra-kernel, hydra-haskell," + , " hydra-java, hydra-python, hydra-scala," + , " hydra-lisp, hydra-coq, hydra-javascript," + , " hydra-pg, hydra-rdf, hydra-ext, hydra-wasm." + , " --all Batch mode: transform every package." + , " --source-set Source set to transform (default: main)." + , " 'test' is only non-empty for hydra-kernel today." + , " --dist-json-root Output root (default: ../../dist/json)." + ] + + +-- | Every supported package (ordering matches hydra.json). +allPackages :: [String] +allPackages = + [ "hydra-kernel" + , "hydra-haskell" + , "hydra-java" + , "hydra-python" + , "hydra-scala" + , "hydra-lisp" + , "hydra-coq" + , "hydra-javascript" + , "hydra-wasm" + , "hydra-pg" + , "hydra-rdf" + , "hydra-ext" + ] + + +-- | Return the test modules owned by the given package. Today, only the +-- kernel has any test modules; other packages return []. +packageTestModules :: String -> [Kernel.Module] +packageTestModules "hydra-kernel" = testModules +packageTestModules _ = [] + + +-- | Return the type-defining modules whose DSL wrappers should be generated +-- for this package. Only kernel and hydra-haskell have DSL wrappers today; +-- other packages return [] and skip DSL generation. +-- +-- Mirrors update-json-main's dslInputMods composition: the kernel DSL pass +-- covers kernel + json + other modules; the haskell DSL pass covers haskell +-- coder modules. Other packages don't produce DSL wrappers. +packageDslInputModules :: String -> [Kernel.Module] +packageDslInputModules "hydra-kernel" = kernelModules ++ jsonModules ++ otherModules +packageDslInputModules "hydra-haskell" = haskellModules +packageDslInputModules _ = [] + + +main :: IO () +main = do + args <- getArgs + opts <- case parseArgs args of + Left err -> do + putStrLn $ "Error: " ++ err + putStrLn "" + putStrLn usage + exitFailure + Right o -> return o + + let srcSet = optSourceSet opts + distRoot = optDistJsonRoot opts + + case optPackage opts of + Just pkg -> runSinglePackage pkg srcSet distRoot + Nothing -> runAllPackages srcSet distRoot + + putStrLn "=== Done. ===" + +-- | Transform a single package. Historical behaviour, kept for scoped +-- callers that invoke one package at a time. +runSinglePackage :: String -> String -> FilePath -> IO () +runSinglePackage pkg srcSet distRoot = do + let outDir = distRoot FP. pkg FP. "src" FP. srcSet FP. "json" + putStrLn $ "=== Transform Haskell DSL -> JSON: " ++ pkg ++ " (" ++ srcSet ++ ") ===" + + let (mods, universe) = case srcSet of + "main" -> + let owned = filter (\m -> namespaceToPackage (Kernel.moduleNamespace m) == pkg) + fullMainUniverse + in (owned, fullMainUniverse) + "test" -> + let ts = packageTestModules pkg + testUniv = fullMainUniverse ++ ts + in (ts, testUniv) + _ -> ([], fullMainUniverse) + + when (null mods) $ do + putStrLn $ " (no modules in " ++ pkg ++ "/" ++ srcSet ++ "; skipping)" + exitSuccess + + putStrLn $ " Writing " ++ show (length mods) ++ " modules -> " ++ outDir + + case srcSet of + "main" -> do + writeModulesJsonPackageSplit True distRoot universe mods + let dslInputs = packageDslInputModules pkg + case dslInputs of + [] -> return () + _ -> do + putStrLn "" + putStrLn $ " Generating DSL wrapper modules for " + ++ show (length dslInputs) ++ " type modules..." + writeDslJsonPackageSplit distRoot universe dslInputs + "test" -> writeModulesJson True outDir universe mods + _ -> return () + +-- | Batch mode: transform every package with one Haskell universe load. +-- writeModulesJsonPackageSplit routes modules to their owning package's +-- per-package JSON tree based on namespaceToPackage, so passing the whole +-- universe produces the same on-disk layout as per-package calls — but +-- we only pay the Haskell startup + DSL-compile cost once. +runAllPackages :: String -> FilePath -> IO () +runAllPackages srcSet distRoot = do + putStrLn $ "=== Transform Haskell DSL -> JSON: all packages (" ++ srcSet ++ ") ===" + + case srcSet of + "main" -> do + putStrLn $ " Writing " ++ show (length fullMainUniverse) + ++ " main modules (routed per-package)..." + writeModulesJsonPackageSplit True distRoot fullMainUniverse fullMainUniverse + -- DSL wrappers: generate for every package that has type-defining + -- inputs. The routing is implicit — wrapper namespaces like + -- hydra.dsl..* resolve to their owning package via + -- packagePrefixes in PackageRouting. + let allDslInputs = concatMap packageDslInputModules allPackages + when (not (null allDslInputs)) $ do + putStrLn "" + putStrLn $ " Generating DSL wrapper modules for " + ++ show (length allDslInputs) ++ " type modules..." + writeDslJsonPackageSplit distRoot fullMainUniverse allDslInputs + "test" -> do + let allTestMods = concatMap packageTestModules allPackages + testUniverse = fullMainUniverse ++ allTestMods + when (null allTestMods) $ do + putStrLn " (no test modules in any package; skipping)" + exitSuccess + -- Today only hydra-kernel has tests, and its tests live at a flat + -- hydra-kernel/src/test/json/ location. writeModulesJson is the + -- direct (non-routing) writer. + let kernelTestDir = distRoot FP. "hydra-kernel" FP. "src" + FP. "test" FP. "json" + putStrLn $ " Writing " ++ show (length allTestMods) + ++ " test modules -> " ++ kernelTestDir + writeModulesJson True kernelTestDir testUniverse allTestMods + _ -> return () diff --git a/src/exec/update-generation-tests/Main.hs b/src/exec/update-generation-tests/Main.hs deleted file mode 100644 --- a/src/exec/update-generation-tests/Main.hs +++ /dev/null @@ -1,46 +0,0 @@ -#!/usr/bin/env stack -{- stack script - --resolver lts-22.28 - --package hydra --} - -module Main where - -import Hydra.Kernel -import Hydra.Generation (createTestGroupLookup, generateGenerationTestSuite) -import Hydra.Ext.Haskell.TestingIo (haskellTestGenerator) -import qualified Hydra.Sources.Test.TestSuite as TestSuite -import qualified Hydra.Test.TestSuite as GenTests - - -main :: IO () -main = do - putStrLn "=== Generate Hydra generation tests ===" - putStrLn "" - - -- Get the namespaces from TestSuite's term dependencies - let testNamespaces = moduleTermDependencies TestSuite.module_ - - -- Build the lookup function from namespaces and test group hierarchy - let lookupFn = createTestGroupLookup testNamespaces GenTests.allTests - - -- Get the list of test modules by looking up each namespace - -- For now, use the libPairs and otherPairs from TestSuite (the actual Module values) - let testModules = TestSuite.testSuiteModules - - -- Generate generation tests to src/gen-test/haskell - let outputDir = "src/gen-test/haskell" - - putStrLn $ "Generating tests into: " ++ outputDir - putStrLn "" - - generateGenerationTestSuite haskellTestGenerator outputDir testModules lookupFn - - putStrLn "" - putStrLn "=== Done! ===" - putStrLn "" - putStrLn "To view the generated tests:" - putStrLn $ " ls -R " ++ outputDir - putStrLn "" - putStrLn "To run the generated tests:" - putStrLn " stack test" diff --git a/src/exec/update-haskell-eval-lib/Main.hs b/src/exec/update-haskell-eval-lib/Main.hs deleted file mode 100644 --- a/src/exec/update-haskell-eval-lib/Main.hs +++ /dev/null @@ -1,17 +0,0 @@ -module Main where - -import Hydra.Generation -import Hydra.Sources.All -import Hydra.Sources.Eval.Lib.All - -main :: IO () -main = do - putStrLn "=== Generate Hydra eval lib (Haskell) ===" - putStrLn "" - putStrLn "Generating eval lib modules to src/gen-main/haskell..." - putStrLn "" - - writeHaskell "src/gen-main/haskell" mainModules evalLibModules - - putStrLn "" - putStrLn "=== Done! ===" diff --git a/src/exec/update-haskell-kernel/Main.hs b/src/exec/update-haskell-kernel/Main.hs deleted file mode 100644 --- a/src/exec/update-haskell-kernel/Main.hs +++ /dev/null @@ -1,22 +0,0 @@ -module Main where - -import Hydra.Generation -import Hydra.Sources.All - -main :: IO () -main = do - putStrLn "=== Generate Hydra kernel (Haskell) ===" - putStrLn "" - putStrLn "Generating main modules to src/gen-main/haskell..." - putStrLn "" - - writeHaskell "src/gen-main/haskell" mainModules mainModules - - putStrLn "" - putStrLn "Generating DSL source module (hydra.dsls) to src/gen-main/haskell..." - putStrLn "" - - writeDslSourceHaskell "src/gen-main/haskell" - - putStrLn "" - putStrLn "=== Done! ===" diff --git a/src/exec/update-haskell-sources/Main.hs b/src/exec/update-haskell-sources/Main.hs deleted file mode 100644 --- a/src/exec/update-haskell-sources/Main.hs +++ /dev/null @@ -1,38 +0,0 @@ -module Main where - -import Hydra.Generation -import Hydra.Sources.All -import Hydra.Sources.Kernel.Types.All - -import System.Directory (getCurrentDirectory, doesFileExist) -import System.Exit (exitFailure) - -main :: IO () -main = do - -- Guard: this executable uses relative paths and must be run from hydra-haskell/ - cwd <- getCurrentDirectory - let marker = "hydra.cabal" - exists <- doesFileExist marker - if not exists - then do - putStrLn $ "Error: this executable must be run from the hydra-haskell/ directory." - putStrLn $ " Current directory: " ++ cwd - putStrLn $ " Expected to find: " ++ marker - putStrLn $ " Hint: cd to hydra-haskell/ and re-run, or use: (cd ../hydra-haskell && stack exec update-haskell-sources)" - exitFailure - else do - putStrLn "=== Generate encoder/decoder source modules (Haskell) ===" - putStrLn "" - putStrLn "Generating decoder source modules to src/gen-main/haskell..." - writeDecoderSourceHaskell "src/gen-main/haskell" mainModules kernelTypesModules - - putStrLn "" - putStrLn "Generating encoder source modules to src/gen-main/haskell..." - writeEncoderSourceHaskell "src/gen-main/haskell" mainModules kernelTypesModules - - putStrLn "" - putStrLn "Generating DSL modules to src/gen-main/haskell..." - writeDslHaskell "src/gen-main/haskell" mainModules mainModules - - putStrLn "" - putStrLn "=== Done! ===" diff --git a/src/exec/update-json-kernel/Main.hs b/src/exec/update-json-kernel/Main.hs --- a/src/exec/update-json-kernel/Main.hs +++ b/src/exec/update-json-kernel/Main.hs @@ -10,7 +10,7 @@ main :: IO () main = do - outputDir <- parseOutputDir "src/gen-main/json" + outputDir <- parseOutputDir "../../dist/json/hydra-kernel/src/main/json" let allMods = kernelModules ++ evalLibModules putStrLn "=== Generate Hydra kernel JSON ===" putStrLn "" diff --git a/src/exec/update-json-main/Main.hs b/src/exec/update-json-main/Main.hs --- a/src/exec/update-json-main/Main.hs +++ b/src/exec/update-json-main/Main.hs @@ -1,50 +1,119 @@ +-- | Export all Hydra DSL modules to JSON, fanned out across per-package +-- directories under dist/json/. +-- +-- Replaces the older update-json-main + update-json-ext split. Every module +-- in the universe is routed to its owning package's dist/json//src/main/json/ +-- directory via the routing table in Hydra.PackageRouting. +-- +-- Universe (deduped by namespace before writing): +-- * hydra-kernel: mainModules + evalLibModules + dslSourceModules +-- * hydra-haskell: haskellModules (already in mainModules; routed here) +-- * coder packages: hydraJavaModules, hydraPythonModules, hydraScalaModules, +-- hydraLispModules +-- * hydra-pg: hydraPgModules + pg decode/encode meta-sources + GenPGTransform +-- * hydra-rdf: hydraRdfModules +-- +-- DSL wrapper modules (hydra.dsl.*) are generated in a second pass with the +-- same routing. + module Main where -import Hydra.Generation (writeModulesJson, writeDslJson) -import Hydra.Sources.All (mainModules, kernelTypesModules) +import Hydra.Generation (writeModulesJsonPackageSplit, writeDslJsonPackageSplit) +import Hydra.PackageRouting (defaultDistJsonRoot) +import Hydra.Sources.Ext ( + mainModules, dslSourceModules, kernelModules, haskellModules, jsonModules, otherModules, + hydraCoqModules, hydraJavaModules, hydraJavaScriptModules, + hydraPythonModules, hydraScalaModules, hydraLispModules, + hydraPgModules, hydraRdfModules, hydraWasmModules, + hydraExtPackageModules, + hydraExtDecodingModules, hydraExtEncodingModules) import Hydra.Sources.Eval.Lib.All (evalLibModules) + +import qualified Hydra.Kernel as Kernel +import qualified Hydra.Sources.Demos.GenPG.Transform as GenPGTransform + +import Control.Exception (catch, SomeException) +import qualified Data.List as L +import qualified Data.Set as S import System.Environment (getArgs) import System.Exit (exitFailure) -import Control.Exception (catch, SomeException) +-- | Deduplicate a list of modules by namespace, keeping the first occurrence. +dedupByNamespace :: [Kernel.Module] -> [Kernel.Module] +dedupByNamespace = go S.empty + where + go _ [] = [] + go seen (m:ms) + | ns `S.member` seen = go seen ms + | otherwise = m : go (S.insert ns seen) ms + where ns = Kernel.moduleNamespace m + main :: IO () main = do - outputDir <- parseOutputDir "src/gen-main/json" - let allMods = mainModules ++ evalLibModules - putStrLn "=== Generate Hydra main modules JSON ===" + distRoot <- parseDistRoot defaultDistJsonRoot + + let universe = dedupByNamespace $ L.concat + [ mainModules + , evalLibModules + , dslSourceModules + , hydraCoqModules + , hydraJavaModules + , hydraJavaScriptModules + , hydraPythonModules + , hydraScalaModules + , hydraLispModules + , hydraPgModules + , hydraRdfModules + , hydraWasmModules + , hydraExtPackageModules + , hydraExtDecodingModules + , hydraExtEncodingModules + , [GenPGTransform.module_] + ] + + putStrLn "=== Generate Hydra JSON modules ===" putStrLn "" - putStrLn $ "Generating " ++ show (length allMods) ++ " main + eval lib modules to JSON..." + putStrLn $ "Generating " ++ show (length universe) ++ " modules to JSON, routed per package..." + putStrLn $ "dist-json root: " ++ distRoot putStrLn "" - result <- catch (writeModulesJson True outputDir allMods allMods >> return True) - (\e -> do - putStrLn $ "Error: " ++ show (e :: SomeException) - return False) + result <- catch + (writeModulesJsonPackageSplit True distRoot universe universe >> return True) + (\e -> do + putStrLn $ "Error: " ++ show (e :: SomeException) + return False) putStrLn "" - putStrLn "Generating DSL modules to JSON..." - dslResult <- catch (writeDslJson outputDir mainModules kernelTypesModules >> return True) - (\e -> do - putStrLn $ "Error generating DSL JSON: " ++ show (e :: SomeException) - return False) + putStrLn "Generating DSL wrapper modules to JSON..." + -- The DSL generator runs over the kernel-side type universe (kernel + json + + -- other + haskell coder). This matches the old behavior of update-json-main: + -- DSL modules are produced for every type in that universe. + let dslInputMods = kernelModules ++ jsonModules ++ otherModules ++ haskellModules + dslResult <- catch + (writeDslJsonPackageSplit distRoot universe dslInputMods >> return True) + (\e -> do + putStrLn $ "Error generating DSL JSON: " ++ show (e :: SomeException) + return False) if result && dslResult then do putStrLn "" putStrLn "=== Done! ===" - putStrLn "" - putStrLn $ "Generated files are in: " ++ outputDir ++ "/" else do putStrLn "" putStrLn "=== FAILED ===" exitFailure -parseOutputDir :: String -> IO String -parseOutputDir defaultDir = do +-- | Parse an optional --dist-root argument. Retains the older --output-dir +-- flag name for call-site compatibility (it is interpreted as a dist-json +-- root now). +parseDistRoot :: String -> IO String +parseDistRoot defaultRoot = do args <- getArgs return $ go args where + go ("--dist-root" : dir : _) = dir go ("--output-dir" : dir : _) = dir - go (_ : rest) = go rest - go [] = defaultDir + go (_ : rest) = go rest + go [] = defaultRoot diff --git a/src/exec/update-json-manifest/Main.hs b/src/exec/update-json-manifest/Main.hs --- a/src/exec/update-json-manifest/Main.hs +++ b/src/exec/update-json-manifest/Main.hs @@ -1,12 +1,69 @@ +-- | Write per-package manifest.json files under dist/json//src/main/json/. +-- +-- Each package's manifest lists only the namespaces it owns. Bootstrap +-- readers (bootstrap-from-json, language hosts) walk multiple package +-- manifests in dependency order rather than reading a single monolithic +-- manifest. + module Main where -import Hydra.Generation (writeManifestJson) +import Hydra.Generation (writePerPackageManifestsJson) +import Hydra.PackageRouting (defaultDistJsonRoot) +import Hydra.Sources.Ext ( + mainModules, dslSourceModules, kernelModules, haskellModules, jsonModules, otherModules, + hydraCoqModules, hydraJavaModules, hydraJavaScriptModules, + hydraPythonModules, hydraScalaModules, hydraLispModules, + hydraPgModules, hydraRdfModules, hydraWasmModules, + hydraExtPackageModules, + hydraExtDecodingModules, hydraExtEncodingModules) +import Hydra.Sources.Eval.Lib.All (evalLibModules) +import Hydra.Sources.Test.All (testModules) +import qualified Hydra.Kernel as Kernel +import qualified Hydra.Sources.Demos.GenPG.Transform as GenPGTransform +import qualified Data.List as L +import qualified Data.Set as S + + +-- | Deduplicate a list of modules by namespace, keeping the first occurrence. +dedupByNamespace :: [Kernel.Module] -> [Kernel.Module] +dedupByNamespace = go S.empty + where + go _ [] = [] + go seen (m:ms) + | ns `S.member` seen = go seen ms + | otherwise = m : go (S.insert ns seen) ms + where ns = Kernel.moduleNamespace m + main :: IO () main = do - putStrLn "=== Generate JSON manifest ===" + putStrLn "=== Generate per-package JSON manifests ===" putStrLn "" - writeManifestJson "src/gen-main/json" + + -- The full main-side universe mirrors update-json-main's input: every + -- module written to JSON should appear in exactly one package's manifest. + let mainUniverse = dedupByNamespace $ L.concat + [ mainModules + , evalLibModules + , dslSourceModules + , hydraCoqModules + , hydraJavaModules + , hydraJavaScriptModules + , hydraPythonModules + , hydraScalaModules + , hydraLispModules + , hydraPgModules + , hydraRdfModules + , hydraWasmModules + , hydraExtPackageModules + , hydraExtDecodingModules + , hydraExtEncodingModules + , [GenPGTransform.module_] + ] + -- DSL generator input: the kernel-side type universe. Matches update-json-main. + let dslInputMods = kernelModules ++ jsonModules ++ otherModules ++ haskellModules + + writePerPackageManifestsJson defaultDistJsonRoot mainUniverse dslInputMods mainUniverse testModules putStrLn "" putStrLn "=== Done! ===" diff --git a/src/exec/update-json-test/Main.hs b/src/exec/update-json-test/Main.hs --- a/src/exec/update-json-test/Main.hs +++ b/src/exec/update-json-test/Main.hs @@ -10,7 +10,7 @@ main :: IO () main = do - outputDir <- parseOutputDir "src/gen-test/json" + outputDir <- parseOutputDir "../../dist/json/hydra-kernel/src/test/json" putStrLn "=== Generate Hydra test modules JSON ===" putStrLn "" putStrLn $ "Generating " ++ show (length testModules) ++ " test modules to JSON..." diff --git a/src/exec/update-kernel-tests/Main.hs b/src/exec/update-kernel-tests/Main.hs deleted file mode 100644 --- a/src/exec/update-kernel-tests/Main.hs +++ /dev/null @@ -1,32 +0,0 @@ -#!/usr/bin/env stack -{- stack script - --resolver lts-22.28 - --package hydra --} - -module Main where - -import Hydra.Generation -import Hydra.Sources.All - -main :: IO () -main = do - putStrLn "=== Generate Hydra kernel tests ===" - putStrLn "" - putStrLn "Generating kernel test modules to src/gen-test/haskell..." - putStrLn "" - - -- Universe provides all modules for dependency resolution - -- testModules now includes all test suite modules (including Reduction, etc.) - -- writeHaskell computes transitive closure to include only what's needed - let allModules = mainModules ++ testModules - writeHaskell "src/gen-test/haskell" allModules testModules - - putStrLn "" - putStrLn "=== Done! ===" - putStrLn "" - putStrLn "To view the generated test modules:" - putStrLn " ls -R src/gen-test/haskell" - putStrLn "" - putStrLn "To run the tests:" - putStrLn " stack test" diff --git a/src/exec/update-wasm/Main.hs b/src/exec/update-wasm/Main.hs new file mode 100644 --- /dev/null +++ b/src/exec/update-wasm/Main.hs @@ -0,0 +1,11 @@ +module Main where + +import Hydra.ExtGeneration + +main :: IO () +main = do + putStrLn "=== Generate WebAssembly text format (WAT) modules ===" + let mods = mainModules <> hydraExtModules + n <- writeWasm "../../dist/wasm/hydra-kernel/src/main/wat" mods mainModules + putStrLn $ "Generated " ++ show n ++ " files" + putStrLn "=== Done! ===" diff --git a/src/exec/verify-json-kernel/Main.hs b/src/exec/verify-json-kernel/Main.hs --- a/src/exec/verify-json-kernel/Main.hs +++ b/src/exec/verify-json-kernel/Main.hs @@ -6,21 +6,22 @@ module Main where import Hydra.Kernel -import Hydra.Module (_Module) +import Hydra.Packaging (_Module) import Hydra.Sources.All (kernelModules) import Hydra.Generation (modulesToGraph) -import Hydra.CodeGeneration (namespaceToPath) +import Hydra.Codegen (namespaceToPath) import qualified Hydra.Json.Model as Json import qualified Hydra.Json.Decode as JsonDecode -import qualified Hydra.Decode.Module as DecodeModule +import qualified Hydra.Decode.Packaging as DecodePackaging import qualified Hydra.Decode.Core as DecodeCore -import qualified Hydra.Rewriting as Rewriting +import qualified Hydra.Strip as Strip import Control.Monad (forM, when) import System.Exit (exitFailure, exitSuccess) -import System.Directory (doesFileExist) -import System.FilePath (()) +import System.Directory (doesFileExist, createDirectoryIfMissing) +import System.FilePath ((), takeDirectory) import System.IO (hFlush, stdout) +import qualified Hydra.Digest as Digest import qualified Data.Map as M import qualified Data.ByteString.Lazy as BS import qualified Data.Aeson as A @@ -41,7 +42,7 @@ mapPair (k, v') = (AK.toString k, aesonToHydra v') A.Array a -> Json.ValueArray (aesonToHydra <$> V.toList a) A.String t -> Json.ValueString $ T.unpack t - A.Number s -> Json.ValueNumber $ SC.toRealFloat s + A.Number s -> Json.ValueNumber s A.Bool b -> Json.ValueBoolean b A.Null -> Json.ValueNull @@ -63,13 +64,65 @@ stripTypeAnnotationsTop (TypeAnnotated (AnnotatedType t _)) = stripTypeAnnotationsTop t stripTypeAnnotationsTop t = t +-- | Path to the per-module verify cache. Content: a v1-style hash map +-- mapping namespace → SHA-256 of the module's JSON file at the time of +-- the last successful verification. On a later verify run, a module +-- whose JSON hash matches its recorded entry is known-good and is +-- skipped. Lives under .stack-work so it's gitignored and worktree-local. +cachePath :: FilePath +cachePath = "../../heads/haskell/.stack-work/verify-json-kernel-per-module-cache.json" + +-- | Load the per-module verify cache. Returns empty map on any error +-- (missing file, malformed JSON, wrong schema). A cache miss just means +-- we re-verify — safe in all cases. +loadCache :: IO (M.Map String String) +loadCache = do + exists <- doesFileExist cachePath + if not exists + then return M.empty + else do + bytes <- BS.readFile cachePath + case A.eitherDecode bytes of + Left _ -> return M.empty + Right v -> case v of + A.Object km -> case AKM.lookup (AK.fromString "hashes") km of + Just (A.Object hm) -> return $ M.fromList + [ (AK.toString k, T.unpack t) + | (k, A.String t) <- AKM.toList hm ] + _ -> return M.empty + _ -> return M.empty + +-- | Write the per-module verify cache. Output is deterministic (sorted +-- keys). Failures in writing are non-fatal: a missed cache is just a +-- re-verify next run. +saveCache :: M.Map String String -> IO () +saveCache hashes = do + createDirectoryIfMissing True (takeDirectory cachePath) + let lns = + [ "{" + , " \"hashes\": {" + ] ++ fmap entry (zip [0..] (M.toAscList hashes)) ++ + [ " }" + , "}" + ] + entry (i, (k, v)) = + " \"" ++ k ++ "\": \"" ++ v ++ "\"" + ++ (if i == M.size hashes - 1 then "" else ",") + writeFile cachePath (unlines lns) + main :: IO () main = do flushPut "=== Verify JSON Kernel ===" flushPut "" - let basePath = "src/gen-main/json" + let basePath = "../../dist/json/hydra-kernel/src/main/json" + -- Load the per-module cache up front. On a no-op sync, every module's + -- JSON hash matches its recorded entry and the verify loop short- + -- circuits each module in microseconds (just a hash + map lookup). + recorded <- loadCache + flushPut $ "Per-module cache: " ++ show (M.size recorded) ++ " recorded entries." + flushPut "Building graph from kernel modules..." -- Build the graph from all kernel modules - this provides the type info let graph = modulesToGraph kernelModules kernelModules @@ -87,67 +140,78 @@ flushPut $ "Verifying " ++ show numModules ++ " kernel modules..." putStrLn "" - -- For each module, read JSON file, decode to Term, then to Module, and compare + -- For each module, read JSON file, decode to Term, then to Module, and compare. + -- Returns (ok, ns, newHashOrEmpty) — newHash is the current file's hash if + -- verification succeeded (so we can record it), empty string on failure or + -- file-not-found. results <- forM kernelModules $ \origMod -> do let ns = moduleNamespace origMod nsStr = unNamespace ns filePath = basePath namespaceToPath ns ++ ".json" - flushPut $ " Processing: " ++ nsStr - exists <- doesFileExist filePath if not exists then do + flushPut $ " Processing: " ++ nsStr flushPut $ " ✗ " ++ nsStr ++ " (file not found)" - return (False, nsStr ++ ": file not found") + return (False, nsStr ++ ": file not found", "") else do - -- Parse JSON using Aeson (fast!) - parseResult <- parseJsonFile filePath - case parseResult of - Left err -> do - flushPut $ " ✗ " ++ nsStr ++ " (JSON parse error)" - flushPut $ " " ++ err - return (False, nsStr ++ ": JSON parse error") - Right jsonVal -> do - flushPut $ " JSON parsed successfully" - - -- Decode JSON to Term using type-directed decoder with Module type - -- The schemaMap is used to resolve type variables - case JsonDecode.fromJson schemaMap (Name "hydra.module.Module") modType jsonVal of + currentHash <- Digest.hashFile filePath + case M.lookup nsStr recorded of + Just rec | rec == currentHash -> do + -- Silent cache hit — verification is deterministic, so a + -- matching hash means the verdict is still "pass". + return (True, nsStr, currentHash) + _ -> do + flushPut $ " Processing: " ++ nsStr + parseResult <- parseJsonFile filePath + case parseResult of Left err -> do - flushPut $ " ✗ " ++ nsStr ++ " (JSON decode error)" + flushPut $ " ✗ " ++ nsStr ++ " (JSON parse error)" flushPut $ " " ++ err - return (False, nsStr ++ ": " ++ err) - Right term -> do - flushPut $ " JSON decoded to Term" - - -- Decode Term to Module - case DecodeModule.module_ graph term of - Left (DecodingError err) -> do - flushPut $ " ✗ " ++ nsStr ++ " (module decode error)" + return (False, nsStr ++ ": JSON parse error", "") + Right jsonVal -> do + flushPut $ " JSON parsed successfully" + case JsonDecode.fromJson schemaMap _Module modType jsonVal of + Left err -> do + flushPut $ " ✗ " ++ nsStr ++ " (JSON decode error)" flushPut $ " " ++ err - return (False, nsStr ++ ": " ++ err) - Right decodedMod -> - let compareMod = if isTypeModule origMod then decodedMod else stripTypeAnnotations decodedMod - compareOrig = if isTypeModule origMod then origMod else stripTypeAnnotations origMod - in if compareMod == compareOrig - then do - flushPut $ " ✓ " ++ nsStr - return (True, nsStr) - else do - flushPut $ " ✗ " ++ nsStr ++ " (content mismatch)" - let diff = findDifference compareOrig compareMod - flushPut $ " " ++ diff - return (False, nsStr ++ ": " ++ diff) + return (False, nsStr ++ ": " ++ err, "") + Right term -> do + flushPut $ " JSON decoded to Term" + case DecodePackaging.module_ graph term of + Left (DecodingError err) -> do + flushPut $ " ✗ " ++ nsStr ++ " (module decode error)" + flushPut $ " " ++ err + return (False, nsStr ++ ": " ++ err, "") + Right decodedMod -> + let compareMod = if isTypeModule origMod then decodedMod else stripTypeAnnotations decodedMod + compareOrig = if isTypeModule origMod then origMod else stripTypeAnnotations origMod + in if compareMod == compareOrig + then do + flushPut $ " ✓ " ++ nsStr + return (True, nsStr, currentHash) + else do + flushPut $ " ✗ " ++ nsStr ++ " (content mismatch)" + let diff = findDifference compareOrig compareMod + flushPut $ " " ++ diff + return (False, nsStr ++ ": " ++ diff, "") - let failures = filter (not . fst) results - successes = filter fst results + let failures = [(ok, msg) | (ok, msg, _) <- results, not ok] + successes = [(ok, msg) | (ok, msg, _) <- results, ok] + newHashes = M.fromList [(ns, h) | (True, ns, h) <- results, not (null h)] + cacheHits = M.size (M.intersectionWith (\a b -> if a == b then () else ()) recorded newHashes) + when (cacheHits > 0) $ + flushPut $ "\nPer-module cache: " ++ show cacheHits + ++ " hits / " ++ show (length kernelModules) ++ " modules (skipped decode+compare)." + putStrLn "" if null failures then do putStrLn "=== SUCCESS ===" putStrLn $ "All " ++ show (length successes) ++ " modules verified successfully!" + saveCache newHashes exitSuccess else do putStrLn "=== FAILED ===" @@ -169,8 +233,8 @@ moduleDefinitions = fmap stripDef (moduleDefinitions m) } where stripDef (DefinitionTerm td) = DefinitionTerm td { - termDefinitionTerm = Rewriting.removeTypesFromTerm (termDefinitionTerm td), - termDefinitionType = Just $ TypeScheme [] (TypeVariable $ Name "hydra.core.Unit") Nothing } + termDefinitionTerm = Strip.removeTypesFromTerm (termDefinitionTerm td), + termDefinitionTypeScheme = Just $ TypeScheme [] (TypeVariable $ Name "hydra.core.Unit") Nothing } stripDef d = d -- | Find the first difference between two modules diff --git a/src/gen-main/haskell/Hydra/Adapt.hs b/src/gen-main/haskell/Hydra/Adapt.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Adapt.hs +++ /dev/null @@ -1,662 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Simple, one-way adapters for types and terms - -module Hydra.Adapt where - -import qualified Hydra.Coders as Coders -import qualified Hydra.Context as Context -import qualified Hydra.Core as Core -import qualified Hydra.Errors as Errors -import qualified Hydra.Graph as Graph -import qualified Hydra.Hoisting as Hoisting -import qualified Hydra.Inference as Inference -import qualified Hydra.Lexical as Lexical -import qualified Hydra.Lib.Eithers as Eithers -import qualified Hydra.Lib.Equality as Equality -import qualified Hydra.Lib.Lists as Lists -import qualified Hydra.Lib.Literals as Literals -import qualified Hydra.Lib.Logic as Logic -import qualified Hydra.Lib.Maps as Maps -import qualified Hydra.Lib.Maybes as Maybes -import qualified Hydra.Lib.Pairs as Pairs -import qualified Hydra.Lib.Sets as Sets -import qualified Hydra.Lib.Strings as Strings -import qualified Hydra.Literals as Literals_ -import qualified Hydra.Module as Module -import qualified Hydra.Names as Names -import qualified Hydra.Reduction as Reduction -import qualified Hydra.Reflect as Reflect -import qualified Hydra.Rewriting as Rewriting -import qualified Hydra.Schemas as Schemas -import qualified Hydra.Show.Core as Core_ -import qualified Hydra.Show.Errors as Errors_ -import qualified Hydra.Util as Util -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | Adapt a graph and its schema to the given language constraints. The doExpand flag controls eta expansion of partial applications. Adaptation is type-preserving: binding-level TypeSchemes are adapted (not stripped). Note: case statement hoisting is done separately, prior to adaptation. The els0 parameter provides the original ordered bindings. Returns both the adapted graph and the ordered adapted bindings. -adaptDataGraph :: Coders.LanguageConstraints -> Bool -> [Core.Binding] -> Context.Context -> Graph.Graph -> Either String (Graph.Graph, [Core.Binding]) -adaptDataGraph constraints doExpand els0 cx graph0 = - - let transform = - \g -> \gterm -> - let tx = g - gterm1 = Rewriting.unshadowVariables (pushTypeAppsInward gterm) - gterm2 = - Rewriting.unshadowVariables (Logic.ifElse doExpand (pushTypeAppsInward (Reduction.etaExpandTermNew tx gterm1)) gterm1) - in (Rewriting.liftLambdaAboveLet gterm2) - litmap = adaptLiteralTypesMap constraints - prims0 = Graph.graphPrimitives graph0 - schemaTypes0 = Graph.graphSchemaTypes graph0 - schemaBindings = Schemas.typesToElements (Maps.map (\ts -> Rewriting.typeSchemeToFType ts) schemaTypes0) - in (Eithers.bind (Logic.ifElse (Maps.null schemaTypes0) (Right Maps.empty) (Eithers.bind (Eithers.bimap (\ic -> Errors.unDecodingError (Context.inContextObject ic)) (\x -> x) (Schemas.graphAsTypes cx graph0 schemaBindings)) (\tmap0 -> Eithers.bind (adaptGraphSchema constraints litmap tmap0) (\tmap1 -> Right (Maps.map (\t -> Schemas.typeToTypeScheme t) tmap1))))) (\schemaResult -> - let adaptedSchemaTypes = schemaResult - gterm0 = - Core.TermLet (Core.Let { - Core.letBindings = els0, - Core.letBody = Core.TermUnit}) - gterm1 = Logic.ifElse doExpand (transform graph0 gterm0) gterm0 - in (Eithers.bind (adaptTerm constraints litmap cx graph0 gterm1) (\gterm2 -> Eithers.bind (Rewriting.rewriteTermM (adaptLambdaDomains constraints litmap) gterm2) (\gterm3 -> - let els1Raw = Schemas.termAsBindings gterm3 - processBinding = - \el -> Eithers.bind (Rewriting.rewriteTermM (adaptNestedTypes constraints litmap) (Core.bindingTerm el)) (\newTerm -> Eithers.bind (Maybes.maybe (Right Nothing) (\ts -> Eithers.bind (adaptTypeScheme constraints litmap ts) (\ts1 -> Right (Just ts1))) (Core.bindingType el)) (\adaptedType -> Right (Core.Binding { - Core.bindingName = (Core.bindingName el), - Core.bindingTerm = newTerm, - Core.bindingType = adaptedType}))) - in (Eithers.bind (Eithers.mapList processBinding els1Raw) (\els1 -> Eithers.bind (Eithers.mapList (\kv -> Eithers.bind (adaptPrimitive constraints litmap (Pairs.second kv)) (\prim1 -> Right (Pairs.first kv, prim1))) (Maps.toList prims0)) (\primPairs -> - let prims1 = Maps.fromList primPairs - adaptedGraphRaw = Lexical.buildGraph els1 Maps.empty prims1 - adaptedGraph = - Graph.Graph { - Graph.graphBoundTerms = (Graph.graphBoundTerms adaptedGraphRaw), - Graph.graphBoundTypes = (Graph.graphBoundTypes adaptedGraphRaw), - Graph.graphClassConstraints = (Graph.graphClassConstraints adaptedGraphRaw), - Graph.graphLambdaVariables = (Graph.graphLambdaVariables adaptedGraphRaw), - Graph.graphMetadata = (Graph.graphMetadata adaptedGraphRaw), - Graph.graphPrimitives = (Graph.graphPrimitives adaptedGraphRaw), - Graph.graphSchemaTypes = adaptedSchemaTypes, - Graph.graphTypeVariables = (Graph.graphTypeVariables adaptedGraphRaw)} - in (Right (adaptedGraph, els1)))))))))) - --- | Attempt to adapt a floating-point type using the given language constraints -adaptFloatType :: Coders.LanguageConstraints -> Core.FloatType -> Maybe Core.FloatType -adaptFloatType constraints ft = - - let supported = Sets.member ft (Coders.languageConstraintsFloatTypes constraints) - alt = adaptFloatType constraints - forUnsupported = - \ft -> case ft of - Core.FloatTypeBigfloat -> alt Core.FloatTypeFloat64 - Core.FloatTypeFloat32 -> alt Core.FloatTypeFloat64 - Core.FloatTypeFloat64 -> alt Core.FloatTypeBigfloat - in (Logic.ifElse supported (Just ft) (forUnsupported ft)) - --- | Adapt a schema graph to the given language constraints -adaptGraphSchema :: Ord t0 => (Coders.LanguageConstraints -> M.Map Core.LiteralType Core.LiteralType -> M.Map t0 Core.Type -> Either String (M.Map t0 Core.Type)) -adaptGraphSchema constraints litmap types0 = - - let mapPair = - \pair -> - let name = Pairs.first pair - typ = Pairs.second pair - in (Eithers.bind (adaptType constraints litmap typ) (\typ1 -> Right (name, typ1))) - in (Eithers.bind (Eithers.mapList mapPair (Maps.toList types0)) (\pairs -> Right (Maps.fromList pairs))) - --- | Attempt to adapt an integer type using the given language constraints -adaptIntegerType :: Coders.LanguageConstraints -> Core.IntegerType -> Maybe Core.IntegerType -adaptIntegerType constraints it = - - let supported = Sets.member it (Coders.languageConstraintsIntegerTypes constraints) - alt = adaptIntegerType constraints - forUnsupported = - \it -> case it of - Core.IntegerTypeBigint -> Nothing - Core.IntegerTypeInt8 -> alt Core.IntegerTypeUint16 - Core.IntegerTypeInt16 -> alt Core.IntegerTypeUint32 - Core.IntegerTypeInt32 -> alt Core.IntegerTypeUint64 - Core.IntegerTypeInt64 -> alt Core.IntegerTypeBigint - Core.IntegerTypeUint8 -> alt Core.IntegerTypeInt16 - Core.IntegerTypeUint16 -> alt Core.IntegerTypeInt32 - Core.IntegerTypeUint32 -> alt Core.IntegerTypeInt64 - Core.IntegerTypeUint64 -> alt Core.IntegerTypeBigint - in (Logic.ifElse supported (Just it) (forUnsupported it)) - --- | Rewrite callback for adapting lambda domain types in a term -adaptLambdaDomains :: Coders.LanguageConstraints -> M.Map Core.LiteralType Core.LiteralType -> (t0 -> Either String Core.Term) -> t0 -> Either String Core.Term -adaptLambdaDomains constraints litmap recurse term = - Eithers.bind (recurse term) (\rewritten -> case rewritten of - Core.TermFunction v0 -> case v0 of - Core.FunctionLambda v1 -> Eithers.bind (Maybes.maybe (Right Nothing) (\dom -> Eithers.bind (adaptType constraints litmap dom) (\dom1 -> Right (Just dom1))) (Core.lambdaDomain v1)) (\adaptedDomain -> Right (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.lambdaParameter v1), - Core.lambdaDomain = adaptedDomain, - Core.lambdaBody = (Core.lambdaBody v1)})))) - _ -> Right (Core.TermFunction v0) - _ -> Right rewritten) - --- | Convert a literal to a different type -adaptLiteral :: Core.LiteralType -> Core.Literal -> Core.Literal -adaptLiteral lt l = - case l of - Core.LiteralBinary v0 -> case lt of - Core.LiteralTypeString -> Core.LiteralString (Literals.binaryToString v0) - Core.LiteralBoolean v0 -> case lt of - Core.LiteralTypeInteger v1 -> Core.LiteralInteger (Literals_.bigintToIntegerValue v1 (Logic.ifElse v0 1 0)) - Core.LiteralFloat v0 -> case lt of - Core.LiteralTypeFloat v1 -> Core.LiteralFloat (Literals_.bigfloatToFloatValue v1 (Literals_.floatValueToBigfloat v0)) - Core.LiteralInteger v0 -> case lt of - Core.LiteralTypeInteger v1 -> Core.LiteralInteger (Literals_.bigintToIntegerValue v1 (Literals_.integerValueToBigint v0)) - --- | Attempt to adapt a literal type using the given language constraints -adaptLiteralType :: Coders.LanguageConstraints -> Core.LiteralType -> Maybe Core.LiteralType -adaptLiteralType constraints lt = - - let forUnsupported = - \lt -> case lt of - Core.LiteralTypeBinary -> Just Core.LiteralTypeString - Core.LiteralTypeBoolean -> Maybes.map (\x -> Core.LiteralTypeInteger x) (adaptIntegerType constraints Core.IntegerTypeInt8) - Core.LiteralTypeFloat v0 -> Maybes.map (\x -> Core.LiteralTypeFloat x) (adaptFloatType constraints v0) - Core.LiteralTypeInteger v0 -> Maybes.map (\x -> Core.LiteralTypeInteger x) (adaptIntegerType constraints v0) - _ -> Nothing - in (Logic.ifElse (literalTypeSupported constraints lt) Nothing (forUnsupported lt)) - --- | Derive a map of adapted literal types for the given language constraints -adaptLiteralTypesMap :: Coders.LanguageConstraints -> M.Map Core.LiteralType Core.LiteralType -adaptLiteralTypesMap constraints = - - let tryType = \lt -> Maybes.maybe Nothing (\lt2 -> Just (lt, lt2)) (adaptLiteralType constraints lt) - in (Maps.fromList (Maybes.cat (Lists.map tryType Reflect.literalTypes))) - --- | Adapt a literal value using the given language constraints -adaptLiteralValue :: Ord t0 => (M.Map t0 Core.LiteralType -> t0 -> Core.Literal -> Core.Literal) -adaptLiteralValue litmap lt l = - Maybes.maybe (Core.LiteralString (Core_.literal l)) (\lt2 -> adaptLiteral lt2 l) (Maps.lookup lt litmap) - --- | Rewrite callback for adapting nested let binding TypeSchemes in a term -adaptNestedTypes :: Coders.LanguageConstraints -> M.Map Core.LiteralType Core.LiteralType -> (t0 -> Either String Core.Term) -> t0 -> Either String Core.Term -adaptNestedTypes constraints litmap recurse term = - Eithers.bind (recurse term) (\rewritten -> case rewritten of - Core.TermLet v0 -> - let adaptB = - \b -> Eithers.bind (Maybes.maybe (Right Nothing) (\ts -> Eithers.bind (adaptTypeScheme constraints litmap ts) (\ts1 -> Right (Just ts1))) (Core.bindingType b)) (\adaptedBType -> Right (Core.Binding { - Core.bindingName = (Core.bindingName b), - Core.bindingTerm = (Core.bindingTerm b), - Core.bindingType = adaptedBType})) - in (Eithers.bind (Eithers.mapList adaptB (Core.letBindings v0)) (\adaptedBindings -> Right (Core.TermLet (Core.Let { - Core.letBindings = adaptedBindings, - Core.letBody = (Core.letBody v0)})))) - _ -> Right rewritten) - --- | Adapt a primitive to the given language constraints, prior to inference -adaptPrimitive :: Coders.LanguageConstraints -> M.Map Core.LiteralType Core.LiteralType -> Graph.Primitive -> Either String Graph.Primitive -adaptPrimitive constraints litmap prim0 = - - let ts0 = Graph.primitiveType prim0 - in (Eithers.bind (adaptTypeScheme constraints litmap ts0) (\ts1 -> Right (Graph.Primitive { - Graph.primitiveName = (Graph.primitiveName prim0), - Graph.primitiveType = ts1, - Graph.primitiveImplementation = (Graph.primitiveImplementation prim0)}))) - --- | Adapt a term using the given language constraints -adaptTerm :: Coders.LanguageConstraints -> M.Map Core.LiteralType Core.LiteralType -> Context.Context -> Graph.Graph -> Core.Term -> Either String Core.Term -adaptTerm constraints litmap cx graph term0 = - - let rewrite = - \recurse -> \term0 -> - let forSupported = - \term -> case term of - Core.TermLiteral v0 -> - let lt = Reflect.literalType v0 - in (Right (Just (Logic.ifElse (literalTypeSupported constraints lt) term (Core.TermLiteral (adaptLiteralValue litmap lt v0))))) - _ -> Right (Just term) - forUnsupported = - \term -> - let forNonNull = - \alts -> Eithers.bind (tryTerm (Lists.head alts)) (\mterm -> Maybes.maybe (tryAlts (Lists.tail alts)) (\t -> Right (Just t)) mterm) - tryAlts = \alts -> Logic.ifElse (Lists.null alts) (Right Nothing) (forNonNull alts) - in (Eithers.bind (termAlternatives cx graph term) (\alts0 -> tryAlts alts0)) - tryTerm = - \term -> - let supportedVariant = Sets.member (Reflect.termVariant term) (Coders.languageConstraintsTermVariants constraints) - in (Logic.ifElse supportedVariant (forSupported term) (forUnsupported term)) - in (Eithers.bind (recurse term0) (\term1 -> case term1 of - Core.TermTypeApplication v0 -> Eithers.bind (adaptType constraints litmap (Core.typeApplicationTermType v0)) (\atyp -> Right (Core.TermTypeApplication (Core.TypeApplicationTerm { - Core.typeApplicationTermBody = (Core.typeApplicationTermBody v0), - Core.typeApplicationTermType = atyp}))) - Core.TermTypeLambda _ -> Right term1 - _ -> Eithers.bind (tryTerm term1) (\mterm -> Maybes.maybe (Left (Strings.cat2 "no alternatives for term: " (Core_.term term1))) (\term2 -> Right term2) mterm))) - in (Rewriting.rewriteTermM rewrite term0) - --- | Adapt a term using the constraints of a given language -adaptTermForLanguage :: Coders.Language -> Context.Context -> Graph.Graph -> Core.Term -> Either String Core.Term -adaptTermForLanguage lang cx g term = - - let constraints = Coders.languageConstraints lang - litmap = adaptLiteralTypesMap constraints - in (adaptTerm constraints litmap cx g term) - --- | Adapt a type using the given language constraints -adaptType :: Coders.LanguageConstraints -> M.Map Core.LiteralType Core.LiteralType -> Core.Type -> Either String Core.Type -adaptType constraints litmap type0 = - - let forSupported = - \typ -> case typ of - Core.TypeLiteral v0 -> Logic.ifElse (literalTypeSupported constraints v0) (Just typ) (Maybes.maybe (Just (Core.TypeLiteral Core.LiteralTypeString)) (\lt2 -> Just (Core.TypeLiteral lt2)) (Maps.lookup v0 litmap)) - _ -> Just typ - forUnsupported = - \typ -> - let tryAlts = - \alts -> Logic.ifElse (Lists.null alts) Nothing (Maybes.maybe (tryAlts (Lists.tail alts)) (\t -> Just t) (tryType (Lists.head alts))) - alts0 = typeAlternatives typ - in (tryAlts alts0) - tryType = - \typ -> - let supportedVariant = Sets.member (Reflect.typeVariant typ) (Coders.languageConstraintsTypeVariants constraints) - in (Logic.ifElse supportedVariant (forSupported typ) (forUnsupported typ)) - rewrite = - \recurse -> \typ -> Eithers.bind (recurse typ) (\type1 -> Maybes.maybe (Left (Strings.cat2 "no alternatives for type: " (Core_.type_ typ))) (\type2 -> Right type2) (tryType type1)) - in (Rewriting.rewriteTypeM rewrite type0) - --- | Adapt a type using the constraints of a given language -adaptTypeForLanguage :: Coders.Language -> Core.Type -> Either String Core.Type -adaptTypeForLanguage lang typ = - - let constraints = Coders.languageConstraints lang - litmap = adaptLiteralTypesMap constraints - in (adaptType constraints litmap typ) - --- | Adapt a type scheme to the given language constraints, prior to inference -adaptTypeScheme :: Coders.LanguageConstraints -> M.Map Core.LiteralType Core.LiteralType -> Core.TypeScheme -> Either String Core.TypeScheme -adaptTypeScheme constraints litmap ts0 = - - let vars0 = Core.typeSchemeVariables ts0 - t0 = Core.typeSchemeType ts0 - in (Eithers.bind (adaptType constraints litmap t0) (\t1 -> Right (Core.TypeScheme { - Core.typeSchemeVariables = vars0, - Core.typeSchemeType = t1, - Core.typeSchemeConstraints = (Core.typeSchemeConstraints ts0)}))) - --- | Compose two coders into a single coder -composeCoders :: Util.Coder t0 t1 -> Util.Coder t1 t2 -> Util.Coder t0 t2 -composeCoders c1 c2 = - Util.Coder { - Util.coderEncode = (\cx -> \a -> Eithers.bind (Util.coderEncode c1 cx a) (\b1 -> Util.coderEncode c2 cx b1)), - Util.coderDecode = (\cx -> \c -> Eithers.bind (Util.coderDecode c2 cx c) (\b2 -> Util.coderDecode c1 cx b2))} - --- | Given a data graph along with language constraints, original ordered bindings, and a designated list of namespaces, adapt the graph to the language constraints, then return the processed graph along with term definitions grouped by namespace (in the order of the input namespaces). Inference is performed before adaptation if bindings lack type annotations. Hoisting must preserve type schemes; if any binding loses its type scheme after hoisting, the pipeline fails. Adaptation preserves type application/lambda wrappers and adapts embedded types. Post-adaptation inference is performed to ensure binding TypeSchemes are fully consistent. The doExpand flag controls eta expansion. The doHoistCaseStatements flag controls case statement hoisting (needed for Python). The doHoistPolymorphicLetBindings flag controls polymorphic let binding hoisting (needed for Java). The originalBindings parameter provides the original ordered bindings (from module elements). -dataGraphToDefinitions :: Coders.LanguageConstraints -> Bool -> Bool -> Bool -> Bool -> [Core.Binding] -> Graph.Graph -> [Module.Namespace] -> Context.Context -> Either String (Graph.Graph, [[Module.TermDefinition]]) -dataGraphToDefinitions constraints doInfer doExpand doHoistCaseStatements doHoistPolymorphicLetBindings originalBindings graph0 namespaces cx = - - let namespacesSet = Sets.fromList namespaces - isParentBinding = - \b -> Maybes.maybe False (\ns -> Sets.member ns namespacesSet) (Names.namespaceOf (Core.bindingName b)) - hoistCases = - \bindings -> - let stripped = - Lists.map (\b -> Core.Binding { - Core.bindingName = (Core.bindingName b), - Core.bindingTerm = (Rewriting.stripTypeLambdas (Core.bindingTerm b)), - Core.bindingType = (Core.bindingType b)}) bindings - term0 = - Core.TermLet (Core.Let { - Core.letBindings = stripped, - Core.letBody = Core.TermUnit}) - unshadowed0 = Schemas.termAsBindings (Rewriting.unshadowVariables term0) - hoisted = Hoisting.hoistCaseStatementsInGraph unshadowed0 - term1 = - Core.TermLet (Core.Let { - Core.letBindings = hoisted, - Core.letBody = Core.TermUnit}) - in (Schemas.termAsBindings (Rewriting.unshadowVariables term1)) - hoistPoly = - \bindings -> - let letBefore = - Core.Let { - Core.letBindings = bindings, - Core.letBody = Core.TermUnit} - letAfter = Hoisting.hoistPolymorphicLetBindings isParentBinding letBefore - in (Core.letBindings letAfter) - checkBindingsTyped = - \debugLabel -> \bindings -> - let untypedBindings = - Lists.map (\b -> Core.unName (Core.bindingName b)) (Lists.filter (\b -> Logic.not (Maybes.isJust (Core.bindingType b))) bindings) - in (Logic.ifElse (Lists.null untypedBindings) (Right bindings) (Left (Strings.cat [ - "Found untyped bindings (", - debugLabel, - "): ", - (Strings.intercalate ", " untypedBindings)]))) - normalizeBindings = - \bindings -> Lists.map (\b -> Core.Binding { - Core.bindingName = (Core.bindingName b), - Core.bindingTerm = (pushTypeAppsInward (Core.bindingTerm b)), - Core.bindingType = (Core.bindingType b)}) bindings - rebuildGraph = - \bindings -> - let g = Lexical.buildGraph bindings Maps.empty (Graph.graphPrimitives graph0) - in Graph.Graph { - Graph.graphBoundTerms = (Graph.graphBoundTerms g), - Graph.graphBoundTypes = (Graph.graphBoundTypes g), - Graph.graphClassConstraints = (Graph.graphClassConstraints g), - Graph.graphLambdaVariables = (Graph.graphLambdaVariables g), - Graph.graphMetadata = (Graph.graphMetadata g), - Graph.graphPrimitives = (Graph.graphPrimitives g), - Graph.graphSchemaTypes = (Graph.graphSchemaTypes graph0), - Graph.graphTypeVariables = (Graph.graphTypeVariables g)} - bins0 = originalBindings - bins1 = Logic.ifElse doHoistCaseStatements (hoistCases bins0) bins0 - in (Eithers.bind (Logic.ifElse doInfer (Eithers.map (\result -> Pairs.second (Pairs.first result)) (Eithers.bimap (\ic -> Errors_.error (Context.inContextObject ic)) (\x -> x) (Inference.inferGraphTypes cx bins1 (rebuildGraph bins1)))) (checkBindingsTyped "after case hoisting" bins1)) (\bins2 -> Eithers.bind (Logic.ifElse doHoistPolymorphicLetBindings (checkBindingsTyped "after let hoisting" (hoistPoly bins2)) (Right bins2)) (\bins3 -> Eithers.bind (adaptDataGraph constraints doExpand bins3 cx (rebuildGraph bins3)) (\adaptResult -> - let adapted = Pairs.first adaptResult - adaptedBindings = Pairs.second adaptResult - in (Eithers.bind (checkBindingsTyped "after adaptation" adaptedBindings) (\bins4 -> - let bins5 = normalizeBindings bins4 - toDef = - \el -> Maybes.map (\ts -> Module.TermDefinition { - Module.termDefinitionName = (Core.bindingName el), - Module.termDefinitionTerm = (Core.bindingTerm el), - Module.termDefinitionType = (Just ts)}) (Core.bindingType el) - selectedElements = - Lists.filter (\el -> Maybes.maybe False (\ns -> Sets.member ns namespacesSet) (Names.namespaceOf (Core.bindingName el))) bins5 - elementsByNamespace = - Lists.foldl (\acc -> \el -> Maybes.maybe acc (\ns -> - let existing = Maybes.maybe [] Equality.identity (Maps.lookup ns acc) - in (Maps.insert ns (Lists.concat2 existing [ - el]) acc)) (Names.namespaceOf (Core.bindingName el))) Maps.empty selectedElements - defsGrouped = - Lists.map (\ns -> - let elsForNs = Maybes.maybe [] Equality.identity (Maps.lookup ns elementsByNamespace) - in (Maybes.cat (Lists.map toDef elsForNs))) namespaces - g = Lexical.buildGraph bins5 Maps.empty (Graph.graphPrimitives adapted) - in (Right (Graph.Graph { - Graph.graphBoundTerms = (Graph.graphBoundTerms g), - Graph.graphBoundTypes = (Graph.graphBoundTypes g), - Graph.graphClassConstraints = (Graph.graphClassConstraints g), - Graph.graphLambdaVariables = (Graph.graphLambdaVariables g), - Graph.graphMetadata = (Graph.graphMetadata g), - Graph.graphPrimitives = (Graph.graphPrimitives g), - Graph.graphSchemaTypes = (Graph.graphSchemaTypes adapted), - Graph.graphTypeVariables = (Graph.graphTypeVariables g)}, defsGrouped)))))))) - --- | Check if a literal type is supported by the given language constraints -literalTypeSupported :: Coders.LanguageConstraints -> Core.LiteralType -> Bool -literalTypeSupported constraints lt = - - let forType = - \lt -> case lt of - Core.LiteralTypeFloat v0 -> Sets.member v0 (Coders.languageConstraintsFloatTypes constraints) - Core.LiteralTypeInteger v0 -> Sets.member v0 (Coders.languageConstraintsIntegerTypes constraints) - _ -> True - in (Logic.ifElse (Sets.member (Reflect.literalTypeVariant lt) (Coders.languageConstraintsLiteralVariants constraints)) (forType lt) False) - --- | Prepare a float type, substituting unsupported types -prepareFloatType :: Core.FloatType -> (Core.FloatType, ((Core.FloatValue -> Core.FloatValue), (S.Set String))) -prepareFloatType ft = - case ft of - Core.FloatTypeBigfloat -> (Core.FloatTypeFloat64, ((\v -> case v of - Core.FloatValueBigfloat v1 -> Core.FloatValueFloat64 (Literals.bigfloatToFloat64 v1) - _ -> v), (Sets.fromList [ - "replace arbitrary-precision floating-point numbers with 64-bit floating-point numbers (doubles)"]))) - _ -> prepareSame ft - --- | Prepare an integer type, substituting unsupported types -prepareIntegerType :: Core.IntegerType -> (Core.IntegerType, ((Core.IntegerValue -> Core.IntegerValue), (S.Set String))) -prepareIntegerType it = - case it of - Core.IntegerTypeBigint -> (Core.IntegerTypeInt64, ((\v -> case v of - Core.IntegerValueBigint v1 -> Core.IntegerValueInt64 (Literals.bigintToInt64 v1) - _ -> v), (Sets.fromList [ - "replace arbitrary-precision integers with 64-bit integers"]))) - Core.IntegerTypeUint8 -> (Core.IntegerTypeInt8, ((\v -> case v of - Core.IntegerValueUint8 v1 -> Core.IntegerValueInt8 (Literals.bigintToInt8 (Literals.uint8ToBigint v1)) - _ -> v), (Sets.fromList [ - "replace unsigned 8-bit integers with signed 8-bit integers"]))) - Core.IntegerTypeUint32 -> (Core.IntegerTypeInt32, ((\v -> case v of - Core.IntegerValueUint32 v1 -> Core.IntegerValueInt32 (Literals.bigintToInt32 (Literals.uint32ToBigint v1)) - _ -> v), (Sets.fromList [ - "replace unsigned 32-bit integers with signed 32-bit integers"]))) - Core.IntegerTypeUint64 -> (Core.IntegerTypeInt64, ((\v -> case v of - Core.IntegerValueUint64 v1 -> Core.IntegerValueInt64 (Literals.bigintToInt64 (Literals.uint64ToBigint v1)) - _ -> v), (Sets.fromList [ - "replace unsigned 64-bit integers with signed 64-bit integers"]))) - _ -> prepareSame it - --- | Prepare a literal type, substituting unsupported types -prepareLiteralType :: Core.LiteralType -> (Core.LiteralType, ((Core.Literal -> Core.Literal), (S.Set String))) -prepareLiteralType at = - case at of - Core.LiteralTypeBinary -> (Core.LiteralTypeString, ((\v -> case v of - Core.LiteralBinary v1 -> Core.LiteralString (Literals.binaryToString v1) - _ -> v), (Sets.fromList [ - "replace binary strings with character strings"]))) - Core.LiteralTypeFloat v0 -> - let result = prepareFloatType v0 - rtyp = Pairs.first result - rep = Pairs.first (Pairs.second result) - msgs = Pairs.second (Pairs.second result) - in (Core.LiteralTypeFloat rtyp, ((\v -> case v of - Core.LiteralFloat v1 -> Core.LiteralFloat (rep v1) - _ -> v), msgs)) - Core.LiteralTypeInteger v0 -> - let result = prepareIntegerType v0 - rtyp = Pairs.first result - rep = Pairs.first (Pairs.second result) - msgs = Pairs.second (Pairs.second result) - in (Core.LiteralTypeInteger rtyp, ((\v -> case v of - Core.LiteralInteger v1 -> Core.LiteralInteger (rep v1) - _ -> v), msgs)) - _ -> prepareSame at - --- | Return a value unchanged with identity transform and no messages -prepareSame :: Ord t2 => (t0 -> (t0, ((t1 -> t1), (S.Set t2)))) -prepareSame x = (x, ((\y -> y), Sets.empty)) - --- | Prepare a type, substituting unsupported literal types -prepareType :: t0 -> Core.Type -> (Core.Type, ((Core.Term -> Core.Term), (S.Set String))) -prepareType cx typ = - case (Rewriting.deannotateType typ) of - Core.TypeLiteral v0 -> - let result = prepareLiteralType v0 - rtyp = Pairs.first result - rep = Pairs.first (Pairs.second result) - msgs = Pairs.second (Pairs.second result) - in (Core.TypeLiteral rtyp, ((\v -> case v of - Core.TermLiteral v1 -> Core.TermLiteral (rep v1) - _ -> v), msgs)) - _ -> prepareSame typ - --- | Normalize a term by pushing TermTypeApplication inward past TermApplication and TermFunction (Lambda). This corrects structures produced by poly-let hoisting and eta expansion, where type applications from inference end up wrapping term applications or lambda abstractions instead of being directly on the polymorphic variable. -pushTypeAppsInward :: Core.Term -> Core.Term -pushTypeAppsInward term = - - let push = - \body -> \typ -> case body of - Core.TermApplication v0 -> go (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm { - Core.typeApplicationTermBody = (Core.applicationFunction v0), - Core.typeApplicationTermType = typ})), - Core.applicationArgument = (Core.applicationArgument v0)})) - Core.TermFunction v0 -> case v0 of - Core.FunctionLambda v1 -> go (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.lambdaParameter v1), - Core.lambdaDomain = (Core.lambdaDomain v1), - Core.lambdaBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { - Core.typeApplicationTermBody = (Core.lambdaBody v1), - Core.typeApplicationTermType = typ}))}))) - _ -> Core.TermTypeApplication (Core.TypeApplicationTerm { - Core.typeApplicationTermBody = (Core.TermFunction v0), - Core.typeApplicationTermType = typ}) - Core.TermLet v0 -> go (Core.TermLet (Core.Let { - Core.letBindings = (Core.letBindings v0), - Core.letBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { - Core.typeApplicationTermBody = (Core.letBody v0), - Core.typeApplicationTermType = typ}))})) - _ -> Core.TermTypeApplication (Core.TypeApplicationTerm { - Core.typeApplicationTermBody = body, - Core.typeApplicationTermType = typ}) - go = - \t -> - let forField = - \fld -> Core.Field { - Core.fieldName = (Core.fieldName fld), - Core.fieldTerm = (go (Core.fieldTerm fld))} - forElimination = - \elm -> case elm of - Core.EliminationRecord v0 -> Core.EliminationRecord v0 - Core.EliminationUnion v0 -> Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.caseStatementTypeName v0), - Core.caseStatementDefault = (Maybes.map go (Core.caseStatementDefault v0)), - Core.caseStatementCases = (Lists.map forField (Core.caseStatementCases v0))}) - Core.EliminationWrap v0 -> Core.EliminationWrap v0 - forFunction = - \fun -> case fun of - Core.FunctionElimination v0 -> Core.FunctionElimination (forElimination v0) - Core.FunctionLambda v0 -> Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.lambdaParameter v0), - Core.lambdaDomain = (Core.lambdaDomain v0), - Core.lambdaBody = (go (Core.lambdaBody v0))}) - Core.FunctionPrimitive v0 -> Core.FunctionPrimitive v0 - forLet = - \lt -> - let mapBinding = - \b -> Core.Binding { - Core.bindingName = (Core.bindingName b), - Core.bindingTerm = (go (Core.bindingTerm b)), - Core.bindingType = (Core.bindingType b)} - in Core.Let { - Core.letBindings = (Lists.map mapBinding (Core.letBindings lt)), - Core.letBody = (go (Core.letBody lt))} - forMap = - \m -> - let forPair = \p -> (go (Pairs.first p), (go (Pairs.second p))) - in (Maps.fromList (Lists.map forPair (Maps.toList m))) - in case t of - Core.TermAnnotated v0 -> Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (go (Core.annotatedTermBody v0)), - Core.annotatedTermAnnotation = (Core.annotatedTermAnnotation v0)}) - Core.TermApplication v0 -> Core.TermApplication (Core.Application { - Core.applicationFunction = (go (Core.applicationFunction v0)), - Core.applicationArgument = (go (Core.applicationArgument v0))}) - Core.TermEither v0 -> Core.TermEither (Eithers.either (\l -> Left (go l)) (\r -> Right (go r)) v0) - Core.TermFunction v0 -> Core.TermFunction (forFunction v0) - Core.TermLet v0 -> Core.TermLet (forLet v0) - Core.TermList v0 -> Core.TermList (Lists.map go v0) - Core.TermLiteral v0 -> Core.TermLiteral v0 - Core.TermMap v0 -> Core.TermMap (forMap v0) - Core.TermMaybe v0 -> Core.TermMaybe (Maybes.map go v0) - Core.TermPair v0 -> Core.TermPair (go (Pairs.first v0), (go (Pairs.second v0))) - Core.TermRecord v0 -> Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.recordTypeName v0), - Core.recordFields = (Lists.map forField (Core.recordFields v0))}) - Core.TermSet v0 -> Core.TermSet (Sets.fromList (Lists.map go (Sets.toList v0))) - Core.TermTypeApplication v0 -> - let body1 = go (Core.typeApplicationTermBody v0) - in (push body1 (Core.typeApplicationTermType v0)) - Core.TermTypeLambda v0 -> Core.TermTypeLambda (Core.TypeLambda { - Core.typeLambdaParameter = (Core.typeLambdaParameter v0), - Core.typeLambdaBody = (go (Core.typeLambdaBody v0))}) - Core.TermUnion v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.injectionTypeName v0), - Core.injectionField = (forField (Core.injectionField v0))}) - Core.TermUnit -> Core.TermUnit - Core.TermVariable v0 -> Core.TermVariable v0 - Core.TermWrap v0 -> Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.wrappedTermTypeName v0), - Core.wrappedTermBody = (go (Core.wrappedTermBody v0))}) - in (go term) - --- | Given a schema graph along with language constraints and a designated list of element names, adapt the graph to the language constraints, then return a corresponding type definition for each element name. -schemaGraphToDefinitions :: Coders.LanguageConstraints -> Graph.Graph -> [[Core.Name]] -> Context.Context -> Either String (M.Map Core.Name Core.Type, [[Module.TypeDefinition]]) -schemaGraphToDefinitions constraints graph nameLists cx = - - let litmap = adaptLiteralTypesMap constraints - in (Eithers.bind (Eithers.bimap (\ic -> Errors.unDecodingError (Context.inContextObject ic)) (\x -> x) (Schemas.graphAsTypes cx graph (Lexical.graphToBindings graph))) (\tmap0 -> Eithers.bind (adaptGraphSchema constraints litmap tmap0) (\tmap1 -> - let toDef = - \pair -> Module.TypeDefinition { - Module.typeDefinitionName = (Pairs.first pair), - Module.typeDefinitionType = (Pairs.second pair)} - in (Right (tmap1, (Lists.map (\names -> Lists.map toDef (Lists.map (\n -> (n, (Maybes.fromJust (Maps.lookup n tmap1)))) names)) nameLists)))))) - --- | Given a target language and a source type, produce an adapter which rewrites the type and its terms according to the language's constraints. The encode direction adapts terms; the decode direction is identity. -simpleLanguageAdapter :: Coders.Language -> t0 -> Graph.Graph -> Core.Type -> Either String (Util.Adapter Core.Type Core.Type Core.Term Core.Term) -simpleLanguageAdapter lang cx g typ = - - let constraints = Coders.languageConstraints lang - litmap = adaptLiteralTypesMap constraints - in (Eithers.bind (adaptType constraints litmap typ) (\adaptedType -> Right (Util.Adapter { - Util.adapterIsLossy = False, - Util.adapterSource = typ, - Util.adapterTarget = adaptedType, - Util.adapterCoder = Util.Coder { - Util.coderEncode = (\cx -> \term -> Eithers.bimap (\_s -> Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError _s)), - Context.inContextContext = cx}) (\_x -> _x) (adaptTerm constraints litmap cx g term)), - Util.coderDecode = (\cx -> \term -> Right term)}}))) - --- | Find a list of alternatives for a given term, if any -termAlternatives :: Context.Context -> Graph.Graph -> Core.Term -> Either String [Core.Term] -termAlternatives cx graph term = - case term of - Core.TermAnnotated v0 -> - let term2 = Core.annotatedTermBody v0 - in (Right [ - term2]) - Core.TermMaybe v0 -> Right [ - Core.TermList (Maybes.maybe [] (\term2 -> [ - term2]) v0)] - Core.TermTypeLambda v0 -> - let term2 = Core.typeLambdaBody v0 - in (Right [ - term2]) - Core.TermTypeApplication v0 -> - let term2 = Core.typeApplicationTermBody v0 - in (Right [ - term2]) - Core.TermUnion v0 -> - let tname = Core.injectionTypeName v0 - field = Core.injectionField v0 - fname = Core.fieldName field - fterm = Core.fieldTerm field - forFieldType = - \ft -> - let ftname = Core.fieldTypeName ft - in Core.Field { - Core.fieldName = fname, - Core.fieldTerm = (Core.TermMaybe (Logic.ifElse (Equality.equal ftname fname) (Just fterm) Nothing))} - in (Eithers.bind (Eithers.bimap (\ic -> Errors_.error (Context.inContextObject ic)) (\x -> x) (Schemas.requireUnionType cx graph tname)) (\rt -> Right [ - Core.TermRecord (Core.Record { - Core.recordTypeName = tname, - Core.recordFields = (Lists.map forFieldType rt)})])) - Core.TermUnit -> Right [ - Core.TermLiteral (Core.LiteralBoolean True)] - Core.TermWrap v0 -> - let term2 = Core.wrappedTermBody v0 - in (Right [ - term2]) - _ -> Right [] - --- | Find a list of alternatives for a given type, if any -typeAlternatives :: Core.Type -> [Core.Type] -typeAlternatives type_ = - case type_ of - Core.TypeAnnotated v0 -> - let type2 = Core.annotatedTypeBody v0 - in [ - type2] - Core.TypeMaybe v0 -> [ - Core.TypeList v0] - Core.TypeUnion v0 -> - let toOptField = - \f -> Core.FieldType { - Core.fieldTypeName = (Core.fieldTypeName f), - Core.fieldTypeType = (Core.TypeMaybe (Core.fieldTypeType f))} - optFields = Lists.map toOptField v0 - in [ - Core.TypeRecord optFields] - Core.TypeUnit -> [ - Core.TypeLiteral Core.LiteralTypeBoolean] - Core.TypeVoid -> [ - Core.TypeUnit] - _ -> [] diff --git a/src/gen-main/haskell/Hydra/Annotations.hs b/src/gen-main/haskell/Hydra/Annotations.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Annotations.hs +++ /dev/null @@ -1,323 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Utilities for reading and writing type and term annotations - -module Hydra.Annotations where - -import qualified Hydra.Classes as Classes -import qualified Hydra.Constants as Constants -import qualified Hydra.Context as Context -import qualified Hydra.Core as Core -import qualified Hydra.Decode.Core as Core_ -import qualified Hydra.Encode.Core as Core__ -import qualified Hydra.Errors as Errors -import qualified Hydra.Extract.Core as Core___ -import qualified Hydra.Graph as Graph -import qualified Hydra.Lib.Eithers as Eithers -import qualified Hydra.Lib.Equality as Equality -import qualified Hydra.Lib.Lists as Lists -import qualified Hydra.Lib.Logic as Logic -import qualified Hydra.Lib.Maps as Maps -import qualified Hydra.Lib.Math as Math -import qualified Hydra.Lib.Maybes as Maybes -import qualified Hydra.Lib.Pairs as Pairs -import qualified Hydra.Lib.Sets as Sets -import qualified Hydra.Lib.Strings as Strings -import qualified Hydra.Rewriting as Rewriting -import qualified Hydra.Show.Core as Core____ -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | Aggregate annotations from nested structures -aggregateAnnotations :: Ord t2 => ((t0 -> Maybe t1) -> (t1 -> t0) -> (t1 -> M.Map t2 t3) -> t0 -> M.Map t2 t3) -aggregateAnnotations getValue getX getAnns t = - - let toPairs = - \rest -> \t -> Maybes.maybe rest (\yy -> toPairs (Lists.cons (Maps.toList (getAnns yy)) rest) (getX yy)) (getValue t) - in (Maps.fromList (Lists.concat (toPairs [] t))) - --- | Debug if the debug ID matches (Either version) -debugIf :: Context.Context -> String -> String -> Either (Context.InContext Errors.Error) () -debugIf cx debugId message = - Eithers.bind (getDebugId cx) (\mid -> Logic.ifElse (Equality.equal mid (Just debugId)) (Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError message)), - Context.inContextContext = cx})) (Right ())) - --- | Fail if the given flag is set (Either version) -failOnFlag :: Context.Context -> Core.Name -> String -> Either (Context.InContext Errors.Error) () -failOnFlag cx flag msg = - Eithers.bind (hasFlag cx flag) (\val -> Logic.ifElse val (Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError msg)), - Context.inContextContext = cx})) (Right ())) - --- | Get an attribute from a context (pure version) -getAttr :: Core.Name -> Context.Context -> Maybe Core.Term -getAttr key cx = Maps.lookup key (Context.contextOther cx) - --- | Get an attribute with a default value from context (pure version) -getAttrWithDefault :: Core.Name -> Core.Term -> Context.Context -> Core.Term -getAttrWithDefault key def cx = Maybes.fromMaybe def (getAttr key cx) - --- | Get a counter value from context (pure version) -getCount :: Core.Name -> Context.Context -> Int -getCount key cx = - Maybes.maybe 0 (\term -> case term of - Core.TermLiteral v0 -> case v0 of - Core.LiteralInteger v1 -> case v1 of - Core.IntegerValueInt32 v2 -> v2 - _ -> 0 - _ -> 0 - _ -> 0) (Maps.lookup key (Context.contextOther cx)) - --- | Get the debug ID from context (Either version) -getDebugId :: Context.Context -> Either (Context.InContext Errors.Error) (Maybe String) -getDebugId cx = - Maybes.maybe (Right Nothing) (\term -> Eithers.map Maybes.pure (Core___.string cx (Graph.Graph { - Graph.graphBoundTerms = Maps.empty, - Graph.graphBoundTypes = Maps.empty, - Graph.graphClassConstraints = Maps.empty, - Graph.graphLambdaVariables = Sets.empty, - Graph.graphMetadata = Maps.empty, - Graph.graphPrimitives = Maps.empty, - Graph.graphSchemaTypes = Maps.empty, - Graph.graphTypeVariables = Sets.empty}) term)) (getAttr Constants.key_debugId cx) - --- | Get description from annotations map (Either version) -getDescription :: Context.Context -> Graph.Graph -> M.Map Core.Name Core.Term -> Either (Context.InContext Errors.Error) (Maybe String) -getDescription cx graph anns = - Maybes.maybe (Right Nothing) (\term -> Eithers.map Maybes.pure (Core___.string cx graph term)) (Maps.lookup (Core.Name "description") anns) - --- | Get a term annotation -getTermAnnotation :: Core.Name -> Core.Term -> Maybe Core.Term -getTermAnnotation key term = Maps.lookup key (termAnnotationInternal term) - --- | Get term description (Either version) -getTermDescription :: Context.Context -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) (Maybe String) -getTermDescription cx graph term = - - let peel = - \t -> case t of - Core.TermTypeLambda v0 -> peel (Core.typeLambdaBody v0) - Core.TermTypeApplication v0 -> peel (Core.typeApplicationTermBody v0) - _ -> t - in (getDescription cx graph (termAnnotationInternal (peel term))) - --- | Get type from annotations -getType :: Graph.Graph -> M.Map Core.Name Core.Term -> Either Errors.DecodingError (Maybe Core.Type) -getType graph anns = - Maybes.maybe (Right Nothing) (\dat -> Eithers.map Maybes.pure (Core_.type_ graph dat)) (Maps.lookup Constants.key_type anns) - --- | Get a type annotation -getTypeAnnotation :: Core.Name -> Core.Type -> Maybe Core.Term -getTypeAnnotation key typ = Maps.lookup key (typeAnnotationInternal typ) - --- | Get type classes from term -getTypeClasses :: Context.Context -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) (M.Map Core.Name (S.Set Classes.TypeClass)) -getTypeClasses cx graph term = - - let decodeClass = - \term -> - let byName = - Maps.fromList [ - (Core.Name "equality", Classes.TypeClassEquality), - (Core.Name "ordering", Classes.TypeClassOrdering)] - in (Eithers.bind (Core___.unitVariant cx (Core.Name "hydra.classes.TypeClass") graph term) (\fn -> Maybes.maybe (Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 "unexpected: expected type class, got " (Core____.term term)))), - Context.inContextContext = cx})) (\x -> Right x) (Maps.lookup fn byName))) - in (Maybes.maybe (Right Maps.empty) (\term -> Core___.map cx (\t -> Eithers.bimap (\de -> Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Errors.unDecodingError de))), - Context.inContextContext = cx}) (\x -> x) (Core_.name graph t)) (Core___.setOf cx decodeClass graph) graph term) (getTermAnnotation Constants.key_classes term)) - --- | Get type description (Either version) -getTypeDescription :: Context.Context -> Graph.Graph -> Core.Type -> Either (Context.InContext Errors.Error) (Maybe String) -getTypeDescription cx graph typ = getDescription cx graph (typeAnnotationInternal typ) - --- | Check if annotations contain description -hasDescription :: M.Map Core.Name t0 -> Bool -hasDescription anns = Maybes.isJust (Maps.lookup Constants.key_description anns) - --- | Check if flag is set (Either version) -hasFlag :: Context.Context -> Core.Name -> Either (Context.InContext Errors.Error) Bool -hasFlag cx flag = - - let term = getAttrWithDefault flag (Core.TermLiteral (Core.LiteralBoolean False)) cx - in (Core___.boolean cx (Graph.Graph { - Graph.graphBoundTerms = Maps.empty, - Graph.graphBoundTypes = Maps.empty, - Graph.graphClassConstraints = Maps.empty, - Graph.graphLambdaVariables = Sets.empty, - Graph.graphMetadata = Maps.empty, - Graph.graphPrimitives = Maps.empty, - Graph.graphSchemaTypes = Maps.empty, - Graph.graphTypeVariables = Sets.empty}) term) - --- | Check if type has description -hasTypeDescription :: Core.Type -> Bool -hasTypeDescription typ = hasDescription (typeAnnotationInternal typ) - --- | For a typed term, decide whether a coder should encode it as a native type expression, or as a Hydra type expression. -isNativeType :: Core.Binding -> Bool -isNativeType el = - - let isFlaggedAsFirstClassType = - Maybes.fromMaybe False (Maybes.map (\_ -> True) (getTermAnnotation Constants.key_firstClassType (Core.bindingTerm el))) - in (Maybes.maybe False (\ts -> Logic.and (Equality.equal ts (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeVariable (Core.Name "hydra.core.Type")), - Core.typeSchemeConstraints = Nothing})) (Logic.not isFlaggedAsFirstClassType)) (Core.bindingType el)) - --- | Return a zero-indexed counter for the given key and updated context (pure version) -nextCount :: Core.Name -> Context.Context -> (Int, Context.Context) -nextCount key cx = - - let count = getCount key cx - in (count, (putCount key (Math.add count 1) cx)) - --- | Normalize term annotations -normalizeTermAnnotations :: Core.Term -> Core.Term -normalizeTermAnnotations term = - - let anns = termAnnotationInternal term - stripped = Rewriting.deannotateTerm term - in (Logic.ifElse (Maps.null anns) stripped (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = stripped, - Core.annotatedTermAnnotation = anns}))) - --- | Normalize type annotations -normalizeTypeAnnotations :: Core.Type -> Core.Type -normalizeTypeAnnotations typ = - - let anns = typeAnnotationInternal typ - stripped = Rewriting.deannotateType typ - in (Logic.ifElse (Maps.null anns) stripped (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = stripped, - Core.annotatedTypeAnnotation = anns}))) - --- | Set an attribute in a context -putAttr :: Core.Name -> Core.Term -> Context.Context -> Context.Context -putAttr key val cx = - Context.Context { - Context.contextTrace = (Context.contextTrace cx), - Context.contextMessages = (Context.contextMessages cx), - Context.contextOther = (Maps.insert key val (Context.contextOther cx))} - --- | Set counter value in context -putCount :: Core.Name -> Int -> Context.Context -> Context.Context -putCount key count cx = putAttr key (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 count))) cx - --- | Reset counter to zero in context -resetCount :: Core.Name -> Context.Context -> Context.Context -resetCount key cx = putAttr key (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 0))) cx - --- | Set annotation in map -setAnnotation :: Ord t0 => (t0 -> Maybe t1 -> M.Map t0 t1 -> M.Map t0 t1) -setAnnotation key val m = Maps.alter (\_ -> val) key m - --- | Set description in annotations -setDescription :: Maybe String -> M.Map Core.Name Core.Term -> M.Map Core.Name Core.Term -setDescription d = - setAnnotation Constants.key_description (Maybes.map (\arg_ -> (\x -> Core.TermLiteral x) ((\x -> Core.LiteralString x) arg_)) d) - --- | Set term annotation -setTermAnnotation :: Core.Name -> Maybe Core.Term -> Core.Term -> Core.Term -setTermAnnotation key val term = - - let term_ = Rewriting.deannotateTerm term - anns = setAnnotation key val (termAnnotationInternal term) - in (Logic.ifElse (Maps.null anns) term_ (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = term_, - Core.annotatedTermAnnotation = anns}))) - --- | Set term description -setTermDescription :: Maybe String -> Core.Term -> Core.Term -setTermDescription d = - setTermAnnotation Constants.key_description (Maybes.map (\s -> Core.TermLiteral (Core.LiteralString s)) d) - --- | Set type in annotations -setType :: Maybe Core.Type -> M.Map Core.Name Core.Term -> M.Map Core.Name Core.Term -setType mt = setAnnotation Constants.key_type (Maybes.map Core__.type_ mt) - --- | Set type annotation -setTypeAnnotation :: Core.Name -> Maybe Core.Term -> Core.Type -> Core.Type -setTypeAnnotation key val typ = - - let typ_ = Rewriting.deannotateType typ - anns = setAnnotation key val (typeAnnotationInternal typ) - in (Logic.ifElse (Maps.null anns) typ_ (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = typ_, - Core.annotatedTypeAnnotation = anns}))) - --- | Set type classes on term -setTypeClasses :: M.Map Core.Name (S.Set Classes.TypeClass) -> Core.Term -> Core.Term -setTypeClasses m term = - - let encodeClass = - \tc -> case tc of - Classes.TypeClassEquality -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.classes.TypeClass"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "equality"), - Core.fieldTerm = Core.TermUnit}}) - Classes.TypeClassOrdering -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.classes.TypeClass"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "ordering"), - Core.fieldTerm = Core.TermUnit}}) - encodePair = - \nameClasses -> - let name = Pairs.first nameClasses - classes = Pairs.second nameClasses - in (Core__.name name, (Core.TermSet (Sets.fromList (Lists.map encodeClass (Sets.toList classes))))) - encoded = Logic.ifElse (Maps.null m) Nothing (Just (Core.TermMap (Maps.fromList (Lists.map encodePair (Maps.toList m))))) - in (setTermAnnotation Constants.key_classes encoded term) - --- | Set type description -setTypeDescription :: Maybe String -> Core.Type -> Core.Type -setTypeDescription d = - setTypeAnnotation Constants.key_description (Maybes.map (\arg_ -> (\x -> Core.TermLiteral x) ((\x -> Core.LiteralString x) arg_)) d) - --- | Get internal term annotations -termAnnotationInternal :: Core.Term -> M.Map Core.Name Core.Term -termAnnotationInternal term = - - let getAnn = - \t -> case t of - Core.TermAnnotated v0 -> Just v0 - _ -> Nothing - in (aggregateAnnotations getAnn (\at -> Core.annotatedTermBody at) (\at -> Core.annotatedTermAnnotation at) term) - --- | Get internal type annotations -typeAnnotationInternal :: Core.Type -> M.Map Core.Name Core.Term -typeAnnotationInternal typ = - - let getAnn = - \t -> case t of - Core.TypeAnnotated v0 -> Just v0 - _ -> Nothing - in (aggregateAnnotations getAnn (\at -> Core.annotatedTypeBody at) (\at -> Core.annotatedTypeAnnotation at) typ) - --- | Create a type element with proper annotations -typeElement :: Core.Name -> Core.Type -> Core.Binding -typeElement name typ = - - let schemaTerm = Core.TermVariable (Core.Name "hydra.core.Type") - dataTerm = - normalizeTermAnnotations (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (Core__.type_ typ), - Core.annotatedTermAnnotation = (Maps.fromList [ - (Constants.key_type, schemaTerm)])})) - in Core.Binding { - Core.bindingName = name, - Core.bindingTerm = dataTerm, - Core.bindingType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeVariable (Core.Name "hydra.core.Type")), - Core.typeSchemeConstraints = Nothing}))} - --- | Execute different branches based on flag (Either version) -whenFlag :: Context.Context -> Core.Name -> Either (Context.InContext Errors.Error) t0 -> Either (Context.InContext Errors.Error) t0 -> Either (Context.InContext Errors.Error) t0 -whenFlag cx flag ethen eelse = Eithers.bind (hasFlag cx flag) (\b -> Logic.ifElse b ethen eelse) diff --git a/src/gen-main/haskell/Hydra/Arity.hs b/src/gen-main/haskell/Hydra/Arity.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Arity.hs +++ /dev/null @@ -1,61 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Functions dealing with arguments and arity. - -module Hydra.Arity where - -import qualified Hydra.Core as Core -import qualified Hydra.Graph as Graph -import qualified Hydra.Lib.Lists as Lists -import qualified Hydra.Lib.Math as Math -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | Find the arity (expected number of arguments) of a function -functionArity :: Core.Function -> Int -functionArity x = - case x of - Core.FunctionElimination _ -> 1 - Core.FunctionLambda v0 -> (\i -> Math.add 1 i) (termArity (Core.lambdaBody v0)) - Core.FunctionPrimitive _ -> 42 - --- | Find the arity (expected number of arguments) of a primitive constant or function -primitiveArity :: Graph.Primitive -> Int -primitiveArity arg_ = (\arg_ -> typeArity (Core.typeSchemeType arg_)) (Graph.primitiveType arg_) - --- | Find the arity (expected number of arguments) of a term -termArity :: Core.Term -> Int -termArity x = - case x of - Core.TermApplication v0 -> (\arg_ -> (\xapp -> Math.sub xapp 1) (termArity arg_)) (Core.applicationFunction v0) - Core.TermFunction v0 -> functionArity v0 - _ -> 0 - --- | Find the arity (expected number of arguments) of a type -typeArity :: Core.Type -> Int -typeArity x = - case x of - Core.TypeAnnotated v0 -> typeArity (Core.annotatedTypeBody v0) - Core.TypeApplication v0 -> typeArity (Core.applicationTypeFunction v0) - Core.TypeForall v0 -> typeArity (Core.forallTypeBody v0) - Core.TypeFunction v0 -> Math.add 1 (typeArity (Core.functionTypeCodomain v0)) - _ -> 0 - --- | Find the arity (expected number of arguments) of a type scheme -typeSchemeArity :: Core.TypeScheme -> Int -typeSchemeArity arg_ = typeArity (Core.typeSchemeType arg_) - --- | Uncurry a type expression into a list of types, turning a function type a -> b into cons a (uncurryType b) -uncurryType :: Core.Type -> [Core.Type] -uncurryType t = - case t of - Core.TypeAnnotated v0 -> uncurryType (Core.annotatedTypeBody v0) - Core.TypeApplication v0 -> uncurryType (Core.applicationTypeFunction v0) - Core.TypeForall v0 -> uncurryType (Core.forallTypeBody v0) - Core.TypeFunction v0 -> Lists.cons (Core.functionTypeDomain v0) (uncurryType (Core.functionTypeCodomain v0)) - _ -> [ - t] diff --git a/src/gen-main/haskell/Hydra/Ast.hs b/src/gen-main/haskell/Hydra/Ast.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Ast.hs +++ /dev/null @@ -1,253 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | A model which provides a common syntax tree for Hydra serializers - -module Hydra.Ast where - -import qualified Hydra.Core as Core -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | Operator associativity -data Associativity = - AssociativityNone | - AssociativityLeft | - AssociativityRight | - AssociativityBoth - deriving (Eq, Ord, Read, Show) - -_Associativity = Core.Name "hydra.ast.Associativity" - -_Associativity_none = Core.Name "none" - -_Associativity_left = Core.Name "left" - -_Associativity_right = Core.Name "right" - -_Associativity_both = Core.Name "both" - --- | Formatting option for code blocks -data BlockStyle = - BlockStyle { - -- | An optional indentation string - blockStyleIndent :: (Maybe String), - -- | Whether to place a newline before the content - blockStyleNewlineBeforeContent :: Bool, - -- | Whether to place a newline after the content - blockStyleNewlineAfterContent :: Bool} - deriving (Eq, Ord, Read, Show) - -_BlockStyle = Core.Name "hydra.ast.BlockStyle" - -_BlockStyle_indent = Core.Name "indent" - -_BlockStyle_newlineBeforeContent = Core.Name "newlineBeforeContent" - -_BlockStyle_newlineAfterContent = Core.Name "newlineAfterContent" - --- | An expression enclosed by brackets -data BracketExpr = - BracketExpr { - -- | The bracket pair enclosing the expression - bracketExprBrackets :: Brackets, - -- | The expression within the brackets - bracketExprEnclosed :: Expr, - -- | The formatting style for the bracketed block - bracketExprStyle :: BlockStyle} - deriving (Eq, Ord, Read, Show) - -_BracketExpr = Core.Name "hydra.ast.BracketExpr" - -_BracketExpr_brackets = Core.Name "brackets" - -_BracketExpr_enclosed = Core.Name "enclosed" - -_BracketExpr_style = Core.Name "style" - --- | Matching open and close bracket symbols -data Brackets = - Brackets { - -- | The opening bracket symbol - bracketsOpen :: Symbol, - -- | The closing bracket symbol - bracketsClose :: Symbol} - deriving (Eq, Ord, Read, Show) - -_Brackets = Core.Name "hydra.ast.Brackets" - -_Brackets_open = Core.Name "open" - -_Brackets_close = Core.Name "close" - --- | An abstract expression -data Expr = - -- | A constant symbol - ExprConst Symbol | - -- | An indented expression - ExprIndent IndentedExpression | - -- | An operator expression - ExprOp OpExpr | - -- | A bracketed expression - ExprBrackets BracketExpr | - -- | A sequence of expressions joined by a separator, treated as structural layout (not subject to parenthesization) - ExprSeq SeqExpr - deriving (Eq, Ord, Read, Show) - -_Expr = Core.Name "hydra.ast.Expr" - -_Expr_const = Core.Name "const" - -_Expr_indent = Core.Name "indent" - -_Expr_op = Core.Name "op" - -_Expr_brackets = Core.Name "brackets" - -_Expr_seq = Core.Name "seq" - --- | An expression indented in a certain style -data IndentedExpression = - IndentedExpression { - -- | The indentation style - indentedExpressionStyle :: IndentStyle, - -- | The expression to be indented - indentedExpressionExpr :: Expr} - deriving (Eq, Ord, Read, Show) - -_IndentedExpression = Core.Name "hydra.ast.IndentedExpression" - -_IndentedExpression_style = Core.Name "style" - -_IndentedExpression_expr = Core.Name "expr" - --- | Any of several indentation styles -data IndentStyle = - -- | Indent all lines with the given string - IndentStyleAllLines String | - -- | Indent only lines after the first with the given string - IndentStyleSubsequentLines String - deriving (Eq, Ord, Read, Show) - -_IndentStyle = Core.Name "hydra.ast.IndentStyle" - -_IndentStyle_allLines = Core.Name "allLines" - -_IndentStyle_subsequentLines = Core.Name "subsequentLines" - --- | An operator symbol -data Op = - Op { - -- | The operator symbol - opSymbol :: Symbol, - -- | The padding around the operator - opPadding :: Padding, - -- | The precedence of the operator - opPrecedence :: Precedence, - -- | The associativity of the operator - opAssociativity :: Associativity} - deriving (Eq, Ord, Read, Show) - -_Op = Core.Name "hydra.ast.Op" - -_Op_symbol = Core.Name "symbol" - -_Op_padding = Core.Name "padding" - -_Op_precedence = Core.Name "precedence" - -_Op_associativity = Core.Name "associativity" - --- | An operator expression -data OpExpr = - OpExpr { - -- | The operator - opExprOp :: Op, - -- | The left-hand side operand - opExprLhs :: Expr, - -- | The right-hand side operand - opExprRhs :: Expr} - deriving (Eq, Ord, Read, Show) - -_OpExpr = Core.Name "hydra.ast.OpExpr" - -_OpExpr_op = Core.Name "op" - -_OpExpr_lhs = Core.Name "lhs" - -_OpExpr_rhs = Core.Name "rhs" - --- | Left and right padding for an operator -data Padding = - Padding { - -- | Padding to the left of the operator - paddingLeft :: Ws, - -- | Padding to the right of the operator - paddingRight :: Ws} - deriving (Eq, Ord, Read, Show) - -_Padding = Core.Name "hydra.ast.Padding" - -_Padding_left = Core.Name "left" - -_Padding_right = Core.Name "right" - --- | Operator precedence -newtype Precedence = - Precedence { - unPrecedence :: Int} - deriving (Eq, Ord, Read, Show) - -_Precedence = Core.Name "hydra.ast.Precedence" - --- | A sequence of expressions joined by a separator operator. Unlike OpExpr, parenthesize ignores SeqExpr boundaries. -data SeqExpr = - SeqExpr { - -- | The separator operator - seqExprOp :: Op, - -- | The expressions to join - seqExprElements :: [Expr]} - deriving (Eq, Ord, Read, Show) - -_SeqExpr = Core.Name "hydra.ast.SeqExpr" - -_SeqExpr_op = Core.Name "op" - -_SeqExpr_elements = Core.Name "elements" - --- | Any symbol -newtype Symbol = - Symbol { - unSymbol :: String} - deriving (Eq, Ord, Read, Show) - -_Symbol = Core.Name "hydra.ast.Symbol" - --- | One of several classes of whitespace -data Ws = - -- | No whitespace - WsNone | - -- | A single space - WsSpace | - -- | A line break - WsBreak | - -- | A line break followed by indentation - WsBreakAndIndent String | - -- | Two line breaks - WsDoubleBreak - deriving (Eq, Ord, Read, Show) - -_Ws = Core.Name "hydra.ast.Ws" - -_Ws_none = Core.Name "none" - -_Ws_space = Core.Name "space" - -_Ws_break = Core.Name "break" - -_Ws_breakAndIndent = Core.Name "breakAndIndent" - -_Ws_doubleBreak = Core.Name "doubleBreak" diff --git a/src/gen-main/haskell/Hydra/Checking.hs b/src/gen-main/haskell/Hydra/Checking.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Checking.hs +++ /dev/null @@ -1,706 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Type checking and type reconstruction (type-of) for the results of Hydra unification and inference - -module Hydra.Checking where - -import qualified Hydra.Coders as Coders -import qualified Hydra.Constants as Constants -import qualified Hydra.Context as Context -import qualified Hydra.Core as Core -import qualified Hydra.Error.Checking as Checking -import qualified Hydra.Error.Core as Core_ -import qualified Hydra.Errors as Errors -import qualified Hydra.Extract.Core as Core__ -import qualified Hydra.Formatting as Formatting -import qualified Hydra.Graph as Graph -import qualified Hydra.Lexical as Lexical -import qualified Hydra.Lib.Eithers as Eithers -import qualified Hydra.Lib.Equality as Equality -import qualified Hydra.Lib.Lists as Lists -import qualified Hydra.Lib.Literals as Literals -import qualified Hydra.Lib.Logic as Logic -import qualified Hydra.Lib.Maps as Maps -import qualified Hydra.Lib.Maybes as Maybes -import qualified Hydra.Lib.Pairs as Pairs -import qualified Hydra.Lib.Sets as Sets -import qualified Hydra.Lib.Strings as Strings -import qualified Hydra.Paths as Paths -import qualified Hydra.Reflect as Reflect -import qualified Hydra.Rewriting as Rewriting -import qualified Hydra.Schemas as Schemas -import qualified Hydra.Show.Core as Core___ -import qualified Hydra.Substitution as Substitution -import qualified Hydra.Typing as Typing -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -allEqual :: Eq t0 => ([t0] -> Bool) -allEqual els = - Logic.ifElse (Lists.null els) True (Lists.foldl (\b -> \t -> Logic.and b (Equality.equal t (Lists.head els))) True (Lists.tail els)) - --- | Apply type arguments to a type, substituting forall-bound variables -applyTypeArgumentsToType :: Context.Context -> Graph.Graph -> [Core.Type] -> Core.Type -> Either (Context.InContext Errors.Error) Core.Type -applyTypeArgumentsToType cx tx typeArgs t = - Logic.ifElse (Lists.null typeArgs) (Right t) ( - let nonnull = - case t of - Core.TypeForall v0 -> - let v = Core.forallTypeParameter v0 - tbody = Core.forallTypeBody v0 - in (applyTypeArgumentsToType cx tx (Lists.tail typeArgs) (Substitution.substInType (Typing.TypeSubst (Maps.singleton v (Lists.head typeArgs))) tbody)) - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat [ - "not a forall type: ", - (Core___.type_ t), - ". Trying to apply ", - (Literals.showInt32 (Lists.length typeArgs)), - " type args: ", - (Formatting.showList Core___.type_ typeArgs), - ". Context has vars: {", - (Strings.intercalate ", " (Lists.map Core.unName (Maps.keys (Graph.graphBoundTypes tx)))), - "}"]))), - Context.inContextContext = cx}) - in nonnull) - --- | Check that a term has no unbound type variables (Either version) -checkForUnboundTypeVariables :: Context.Context -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) () -checkForUnboundTypeVariables cx tx term0 = - - let svars = Sets.fromList (Maps.keys (Graph.graphSchemaTypes tx)) - checkRecursive = - \vars -> \trace -> \lbinding -> \term -> - let recurse = checkRecursive vars trace lbinding - dflt = Eithers.bind (Eithers.mapList recurse (Rewriting.subterms term)) (\_ -> Right ()) - check = - \typ -> - let freevars = Rewriting.freeVariablesInType typ - badvars = Sets.difference (Sets.difference freevars vars) svars - in (Logic.ifElse (Sets.null badvars) (Right ()) (Left (Context.InContext { - Context.inContextObject = (Errors.ErrorChecking (Checking.CheckingErrorUnboundTypeVariables (Checking.UnboundTypeVariablesError { - Checking.unboundTypeVariablesErrorVariables = badvars, - Checking.unboundTypeVariablesErrorType = typ}))), - Context.inContextContext = cx}))) - checkOptional = \m -> Eithers.bind (Eithers.mapMaybe check m) (\_ -> Right ()) - in case term of - Core.TermFunction v0 -> case v0 of - Core.FunctionElimination _ -> dflt - Core.FunctionLambda v1 -> Eithers.bind (checkOptional (Core.lambdaDomain v1)) (\_ -> recurse (Core.lambdaBody v1)) - _ -> dflt - Core.TermLet v0 -> - let forBinding = - \b -> - let bterm = Core.bindingTerm b - newVars = Maybes.maybe vars (\ts -> Sets.union vars (Sets.fromList (Core.typeSchemeVariables ts))) (Core.bindingType b) - newTrace = Lists.cons (Core.unName (Core.bindingName b)) trace - in (checkRecursive newVars newTrace (Just b) bterm) - in (Eithers.bind (Eithers.mapList forBinding (Core.letBindings v0)) (\_ -> recurse (Core.letBody v0))) - Core.TermTypeApplication v0 -> Eithers.bind (check (Core.typeApplicationTermType v0)) (\_ -> recurse (Core.typeApplicationTermBody v0)) - Core.TermTypeLambda v0 -> Eithers.bind (check (Core.TypeVariable (Core.typeLambdaParameter v0))) (\_ -> recurse (Core.typeLambdaBody v0)) - _ -> dflt - in (checkRecursive Sets.empty [ - "top level"] Nothing term0) - --- | Check that a nominal type is applied to the correct number of type arguments (Either version) -checkNominalApplication :: Context.Context -> Graph.Graph -> Core.Name -> [Core.Type] -> Either (Context.InContext Errors.Error) ((), Context.Context) -checkNominalApplication cx tx tname typeArgs = - Eithers.bind (Schemas.requireSchemaType cx (Graph.graphSchemaTypes tx) tname) (\result -> - let schemaType = Pairs.first result - cx2 = Pairs.second result - vars = Core.typeSchemeVariables schemaType - varslen = Lists.length vars - argslen = Lists.length typeArgs - in (Logic.ifElse (Equality.equal varslen argslen) (Right ((), cx2)) (Left (Context.InContext { - Context.inContextObject = (Errors.ErrorChecking (Checking.CheckingErrorTypeArityMismatch (Checking.TypeArityMismatchError { - Checking.typeArityMismatchErrorType = (Core.TypeVariable tname), - Checking.typeArityMismatchErrorExpectedArity = varslen, - Checking.typeArityMismatchErrorActualArity = argslen, - Checking.typeArityMismatchErrorTypeArguments = typeArgs}))), - Context.inContextContext = cx2})))) - --- | Ensure all types in a list are equal and return the common type -checkSameType :: Context.Context -> Graph.Graph -> String -> [Core.Type] -> Either (Context.InContext Errors.Error) Core.Type -checkSameType cx tx desc types = - Logic.ifElse (typesAllEffectivelyEqual tx types) (Right (Lists.head types)) (Left (Context.InContext { - Context.inContextObject = (Errors.ErrorChecking (Checking.CheckingErrorUnequalTypes (Checking.UnequalTypesError { - Checking.unequalTypesErrorTypes = types, - Checking.unequalTypesErrorDescription = desc}))), - Context.inContextContext = cx})) - --- | Check that a term has the expected type -checkType :: Context.Context -> Graph.Graph -> Core.Term -> Core.Type -> Either (Context.InContext Errors.Error) () -checkType cx tx term typ = - - let vars = Graph.graphTypeVariables tx - in (Logic.ifElse Constants.debugInference (Eithers.bind (Eithers.map (\_p -> Pairs.first _p) (typeOf cx tx [] term)) (\t0 -> Logic.ifElse (typesEffectivelyEqual tx t0 typ) (Right ()) (Left (Context.InContext { - Context.inContextObject = (Errors.ErrorChecking (Checking.CheckingErrorTypeMismatch (Checking.TypeMismatchError { - Checking.typeMismatchErrorExpectedType = typ, - Checking.typeMismatchErrorActualType = t0}))), - Context.inContextContext = cx})))) (Right ())) - --- | Sanity-check a type substitution arising from unification. Specifically, check that schema types have not been inappropriately unified with type variables inferred from terms. -checkTypeSubst :: Context.Context -> Graph.Graph -> Typing.TypeSubst -> Either (Context.InContext Errors.Error) Typing.TypeSubst -checkTypeSubst cx tx subst = - - let s = Typing.unTypeSubst subst - vars = Sets.fromList (Maps.keys s) - suspectVars = Sets.intersection vars (Sets.fromList (Maps.keys (Graph.graphSchemaTypes tx))) - isNominal = - \ts -> case (Rewriting.deannotateType (Core.typeSchemeType ts)) of - Core.TypeRecord _ -> True - Core.TypeUnion _ -> True - Core.TypeWrap _ -> True - _ -> False - badVars = - Sets.fromList (Lists.filter (\v -> Maybes.maybe False isNominal (Lexical.dereferenceSchemaType v (Graph.graphSchemaTypes tx))) (Sets.toList suspectVars)) - badPairs = Lists.filter (\p -> Sets.member (Pairs.first p) badVars) (Maps.toList s) - printPair = \p -> Strings.cat2 (Strings.cat2 (Core.unName (Pairs.first p)) " --> ") (Core___.type_ (Pairs.second p)) - in (Logic.ifElse (Sets.null badVars) (Right subst) (Left (Context.InContext { - Context.inContextObject = (Errors.ErrorChecking (Checking.CheckingErrorIncorrectUnification (Checking.IncorrectUnificationError { - Checking.incorrectUnificationErrorSubstitution = subst}))), - Context.inContextContext = cx}))) - --- | Check that all type variables in a type are bound. NOTE: This check is currently disabled to allow phantom type variables from polymorphic instantiation to pass through. The proper fix is to ensure `typeOf` doesn't create fresh variables for post-inference code. -checkTypeVariables :: t0 -> t1 -> () -checkTypeVariables _tx _typ = () - --- | Check if a type contains any type variable from the current scope -containsInScopeTypeVars :: Graph.Graph -> Core.Type -> Bool -containsInScopeTypeVars tx t = - - let vars = Graph.graphTypeVariables tx - freeVars = Rewriting.freeVariablesInTypeSimple t - in (Logic.not (Sets.null (Sets.intersection vars freeVars))) - --- | Normalize free type variables in a type to canonical names based on order of first occurrence. This allows comparing types that differ only in the naming of free type variables. -normalizeTypeFreeVars :: Core.Type -> Core.Type -normalizeTypeFreeVars typ = - - let collectVars = - \acc -> \t -> case t of - Core.TypeVariable v0 -> Logic.ifElse (Maps.member v0 acc) acc (Maps.insert v0 (Core.Name (Strings.cat2 "_tv" (Literals.showInt32 (Maps.size acc)))) acc) - _ -> acc - subst = Rewriting.foldOverType Coders.TraversalOrderPre collectVars Maps.empty typ - in (Rewriting.substituteTypeVariables subst typ) - --- | Get the bound types from a graph as a type environment -toFContext :: Graph.Graph -> M.Map Core.Name Core.Type -toFContext cx = Maps.map Rewriting.typeSchemeToFType (Graph.graphBoundTypes cx) - --- | Check whether two lists of types are effectively equal, disregarding type aliases -typeListsEffectivelyEqual :: Graph.Graph -> [Core.Type] -> [Core.Type] -> Bool -typeListsEffectivelyEqual tx tlist1 tlist2 = - Logic.ifElse (Equality.equal (Lists.length tlist1) (Lists.length tlist2)) (Lists.foldl Logic.and True (Lists.zipWith (typesEffectivelyEqual tx) tlist1 tlist2)) False - --- | Given a type context, reconstruct the type of a System F term -typeOf :: Context.Context -> Graph.Graph -> [Core.Type] -> Core.Term -> Either (Context.InContext Errors.Error) (Core.Type, Context.Context) -typeOf cx tx typeArgs term = - - let cx1 = - Context.Context { - Context.contextTrace = (Lists.cons "typeOf" (Context.contextTrace cx)), - Context.contextMessages = (Context.contextMessages cx), - Context.contextOther = (Context.contextOther cx)} - in case term of - Core.TermAnnotated v0 -> typeOfAnnotatedTerm cx1 tx typeArgs v0 - Core.TermApplication v0 -> typeOfApplication cx1 tx typeArgs v0 - Core.TermEither v0 -> typeOfEither cx1 tx typeArgs v0 - Core.TermFunction v0 -> case v0 of - Core.FunctionElimination v1 -> case v1 of - Core.EliminationRecord v2 -> typeOfProjection cx1 tx typeArgs v2 - Core.EliminationUnion v2 -> typeOfCaseStatement cx1 tx typeArgs v2 - Core.EliminationWrap v2 -> typeOfUnwrap cx1 tx typeArgs v2 - Core.FunctionLambda v1 -> typeOfLambda cx1 tx typeArgs v1 - Core.FunctionPrimitive v1 -> typeOfPrimitive cx1 tx typeArgs v1 - Core.TermLet v0 -> typeOfLet cx1 tx typeArgs v0 - Core.TermList v0 -> typeOfList cx1 tx typeArgs v0 - Core.TermLiteral v0 -> typeOfLiteral cx1 tx typeArgs v0 - Core.TermMap v0 -> typeOfMap cx1 tx typeArgs v0 - Core.TermMaybe v0 -> typeOfMaybe cx1 tx typeArgs v0 - Core.TermPair v0 -> typeOfPair cx1 tx typeArgs v0 - Core.TermRecord v0 -> typeOfRecord cx1 tx typeArgs v0 - Core.TermSet v0 -> typeOfSet cx1 tx typeArgs v0 - Core.TermTypeApplication v0 -> typeOfTypeApplication cx1 tx typeArgs v0 - Core.TermTypeLambda v0 -> typeOfTypeLambda cx1 tx typeArgs v0 - Core.TermUnion v0 -> typeOfInjection cx1 tx typeArgs v0 - Core.TermUnit -> typeOfUnit cx1 tx typeArgs - Core.TermVariable v0 -> typeOfVariable cx1 tx typeArgs v0 - Core.TermWrap v0 -> typeOfWrappedTerm cx1 tx typeArgs v0 - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorChecking (Checking.CheckingErrorUnsupportedTermVariant (Checking.UnsupportedTermVariantError { - Checking.unsupportedTermVariantErrorTermVariant = (Reflect.termVariant term)}))), - Context.inContextContext = cx1}) - --- | Reconstruct the type of an annotated term (Either/Context version) -typeOfAnnotatedTerm :: Context.Context -> Graph.Graph -> [Core.Type] -> Core.AnnotatedTerm -> Either (Context.InContext Errors.Error) (Core.Type, Context.Context) -typeOfAnnotatedTerm cx tx typeArgs at = typeOf cx tx typeArgs (Core.annotatedTermBody at) - --- | Reconstruct the type of an application term (Either/Context version) -typeOfApplication :: Context.Context -> Graph.Graph -> [Core.Type] -> Core.Application -> Either (Context.InContext Errors.Error) (Core.Type, Context.Context) -typeOfApplication cx tx typeArgs app = - - let fun = Core.applicationFunction app - arg = Core.applicationArgument app - tryType = - \cx0 -> \tfun -> \targ -> case tfun of - Core.TypeForall v0 -> tryType cx0 (Core.forallTypeBody v0) targ - Core.TypeFunction v0 -> - let dom = Core.functionTypeDomain v0 - cod = Core.functionTypeCodomain v0 - in (Logic.ifElse (typesEffectivelyEqual tx dom targ) (Right (cod, cx0)) (Left (Context.InContext { - Context.inContextObject = (Errors.ErrorChecking (Checking.CheckingErrorTypeMismatch (Checking.TypeMismatchError { - Checking.typeMismatchErrorExpectedType = dom, - Checking.typeMismatchErrorActualType = targ}))), - Context.inContextContext = cx0}))) - Core.TypeVariable _ -> - let nameResult = Schemas.freshName cx0 - freshN = Pairs.first nameResult - cx1 = Pairs.second nameResult - in (Right (Core.TypeVariable freshN, cx1)) - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorChecking (Checking.CheckingErrorNotAFunctionType (Checking.NotAFunctionTypeError { - Checking.notAFunctionTypeErrorType = tfun}))), - Context.inContextContext = cx0}) - in (Eithers.bind (typeOf cx tx [] fun) (\result1 -> - let tfun = Pairs.first result1 - cx2 = Pairs.second result1 - in (Eithers.bind (typeOf cx2 tx [] arg) (\result2 -> - let targ = Pairs.first result2 - cx3 = Pairs.second result2 - in (Eithers.bind (tryType cx3 tfun targ) (\result3 -> - let t = Pairs.first result3 - cx4 = Pairs.second result3 - in (Eithers.bind (applyTypeArgumentsToType cx4 tx typeArgs t) (\applied -> Right (applied, cx4))))))))) - --- | Reconstruct the type of a case statement (Either/Context version) -typeOfCaseStatement :: Context.Context -> Graph.Graph -> [Core.Type] -> Core.CaseStatement -> Either (Context.InContext Errors.Error) (Core.Type, Context.Context) -typeOfCaseStatement cx tx typeArgs cs = - - let tname = Core.caseStatementTypeName cs - dflt = Core.caseStatementDefault cs - cases = Core.caseStatementCases cs - cterms = Lists.map Core.fieldTerm cases - in (Eithers.bind (Eithers.mapMaybe (\e -> typeOf cx tx [] e) dflt) (\dfltResult -> - let tdflt = Maybes.map Pairs.first dfltResult - cx2 = Maybes.maybe cx Pairs.second dfltResult - foldResult = - Lists.foldl (\acc -> \term -> Eithers.bind acc (\accR -> - let types = Pairs.first accR - cxA = Pairs.second accR - in (Eithers.bind (typeOf cxA tx [] term) (\tResult -> - let t = Pairs.first tResult - cxB = Pairs.second tResult - in (Right (Lists.concat2 types (Lists.pure t), cxB)))))) (Right ([], cx2)) cterms - in (Eithers.bind foldResult (\foldR -> - let tcterms = Pairs.first foldR - cx3 = Pairs.second foldR - fcodsResult = - Lists.foldl (\acc -> \t -> Eithers.bind acc (\accR -> - let cods = Pairs.first accR - in (Eithers.bind (Core__.functionType cx3 t) (\ft -> Right (Lists.concat2 cods (Lists.pure (Core.functionTypeCodomain ft)), cx3))))) (Right ([], cx3)) tcterms - in (Eithers.bind fcodsResult (\fcodsR -> - let fcods = Pairs.first fcodsR - cods = Maybes.cat (Lists.cons tdflt (Lists.map Maybes.pure fcods)) - in (Eithers.bind (checkSameType cx3 tx "case branches" cods) (\cod -> Right (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Schemas.nominalApplication tname typeArgs), - Core.functionTypeCodomain = cod}), cx3))))))))) - --- | Reconstruct the type of an either value (Either/Context version) -typeOfEither :: Context.Context -> Graph.Graph -> [Core.Type] -> Either Core.Term Core.Term -> Either (Context.InContext Errors.Error) (Core.Type, Context.Context) -typeOfEither cx tx typeArgs et = - - let n = Lists.length typeArgs - in (Logic.ifElse (Equality.equal n 2) (Eithers.either (\leftTerm -> Eithers.bind (typeOf cx tx [] leftTerm) (\result -> - let leftType = Pairs.first result - cx2 = Pairs.second result - in (Right (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = leftType, - Core.eitherTypeRight = (Lists.at 1 typeArgs)}), cx2)))) (\rightTerm -> Eithers.bind (typeOf cx tx [] rightTerm) (\result -> - let rightType = Pairs.first result - cx2 = Pairs.second result - in (Right (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Lists.at 0 typeArgs), - Core.eitherTypeRight = rightType}), cx2)))) et) (Left (Context.InContext { - Context.inContextObject = (Errors.ErrorChecking (Checking.CheckingErrorTypeArityMismatch (Checking.TypeArityMismatchError { - Checking.typeArityMismatchErrorType = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = Core.TypeUnit, - Core.eitherTypeRight = Core.TypeUnit})), - Checking.typeArityMismatchErrorExpectedArity = 2, - Checking.typeArityMismatchErrorActualArity = n, - Checking.typeArityMismatchErrorTypeArguments = typeArgs}))), - Context.inContextContext = cx}))) - --- | Reconstruct the type of a union injection (Either/Context version) -typeOfInjection :: Context.Context -> Graph.Graph -> [Core.Type] -> Core.Injection -> Either (Context.InContext Errors.Error) (Core.Type, Context.Context) -typeOfInjection cx tx typeArgs injection = - - let tname = Core.injectionTypeName injection - field = Core.injectionField injection - fname = Core.fieldName field - fterm = Core.fieldTerm field - in (Eithers.bind (Schemas.requireSchemaType cx (Graph.graphSchemaTypes tx) tname) (\schemaResult -> - let schemaType = Pairs.first schemaResult - cx2 = Pairs.second schemaResult - svars = Core.typeSchemeVariables schemaType - sbody = Core.typeSchemeType schemaType - in (Eithers.bind (Core__.unionType cx2 tname sbody) (\sfields -> Eithers.bind (Schemas.findFieldType cx2 fname sfields) (\ftyp -> Right (Schemas.nominalApplication tname typeArgs, cx2)))))) - --- | Reconstruct the type of a lambda function (Either/Context version) -typeOfLambda :: Context.Context -> Graph.Graph -> [Core.Type] -> Core.Lambda -> Either (Context.InContext Errors.Error) (Core.Type, Context.Context) -typeOfLambda cx tx typeArgs l = - - let v = Core.lambdaParameter l - mdom = Core.lambdaDomain l - body = Core.lambdaBody l - in (Eithers.bind (Maybes.maybe (Left (Context.InContext { - Context.inContextObject = (Errors.ErrorChecking (Checking.CheckingErrorUntypedLambda (Checking.UntypedLambdaError { - }))), - Context.inContextContext = cx})) (\dom -> - let types2 = Maps.insert v (Rewriting.fTypeToTypeScheme dom) (Graph.graphBoundTypes tx) - in (Eithers.bind (typeOf cx (Graph.Graph { - Graph.graphBoundTerms = (Graph.graphBoundTerms tx), - Graph.graphBoundTypes = types2, - Graph.graphClassConstraints = (Graph.graphClassConstraints tx), - Graph.graphLambdaVariables = (Graph.graphLambdaVariables tx), - Graph.graphMetadata = (Graph.graphMetadata tx), - Graph.graphPrimitives = (Graph.graphPrimitives tx), - Graph.graphSchemaTypes = (Graph.graphSchemaTypes tx), - Graph.graphTypeVariables = (Graph.graphTypeVariables tx)}) [] body) (\codResult -> - let cod = Pairs.first codResult - cx2 = Pairs.second codResult - in (Right (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = dom, - Core.functionTypeCodomain = cod}), cx2))))) mdom) (\tbodyResult -> - let tbody = Pairs.first tbodyResult - cx3 = Pairs.second tbodyResult - in (Eithers.bind (applyTypeArgumentsToType cx3 tx typeArgs tbody) (\applied -> Right (applied, cx3))))) - --- | Reconstruct the type of a let binding (Either/Context version) -typeOfLet :: Context.Context -> Graph.Graph -> [Core.Type] -> Core.Let -> Either (Context.InContext Errors.Error) (Core.Type, Context.Context) -typeOfLet cx tx typeArgs letTerm = - - let bs = Core.letBindings letTerm - body = Core.letBody letTerm - bnames = Lists.map Core.bindingName bs - bindingType = - \b -> Maybes.maybe (Left (Context.InContext { - Context.inContextObject = (Errors.ErrorChecking (Checking.CheckingErrorUntypedLetBinding (Checking.UntypedLetBindingError { - Checking.untypedLetBindingErrorBinding = b}))), - Context.inContextContext = cx})) (\ts -> Right (Rewriting.typeSchemeToFType ts)) (Core.bindingType b) - btypesResult = - Lists.foldl (\acc -> \b -> Eithers.bind acc (\accR -> - let types = Pairs.first accR - in (Eithers.bind (bindingType b) (\btype -> Right (Lists.concat2 types (Lists.pure btype), ()))))) (Right ([], ())) bs - in (Eithers.bind btypesResult (\btypesR -> - let btypes = Pairs.first btypesR - tx2 = - Graph.Graph { - Graph.graphBoundTerms = (Graph.graphBoundTerms tx), - Graph.graphBoundTypes = (Maps.union (Maps.fromList (Lists.zip bnames (Lists.map Rewriting.fTypeToTypeScheme btypes))) (Graph.graphBoundTypes tx)), - Graph.graphClassConstraints = (Graph.graphClassConstraints tx), - Graph.graphLambdaVariables = (Graph.graphLambdaVariables tx), - Graph.graphMetadata = (Graph.graphMetadata tx), - Graph.graphPrimitives = (Graph.graphPrimitives tx), - Graph.graphSchemaTypes = (Graph.graphSchemaTypes tx), - Graph.graphTypeVariables = (Graph.graphTypeVariables tx)} - in (Eithers.bind (typeOf cx tx2 [] body) (\tResult -> - let t = Pairs.first tResult - cx2 = Pairs.second tResult - in (Eithers.bind (applyTypeArgumentsToType cx2 tx typeArgs t) (\applied -> Right (applied, cx2))))))) - --- | Reconstruct the type of a list (Either/Context version) -typeOfList :: Context.Context -> Graph.Graph -> [Core.Type] -> [Core.Term] -> Either (Context.InContext Errors.Error) (Core.Type, Context.Context) -typeOfList cx tx typeArgs els = - Logic.ifElse (Lists.null els) (Logic.ifElse (Equality.equal (Lists.length typeArgs) 1) (Right (Core.TypeList (Lists.head typeArgs), cx)) (Left (Context.InContext { - Context.inContextObject = (Errors.ErrorChecking (Checking.CheckingErrorTypeArityMismatch (Checking.TypeArityMismatchError { - Checking.typeArityMismatchErrorType = (Core.TypeList Core.TypeUnit), - Checking.typeArityMismatchErrorExpectedArity = 1, - Checking.typeArityMismatchErrorActualArity = (Lists.length typeArgs), - Checking.typeArityMismatchErrorTypeArguments = typeArgs}))), - Context.inContextContext = cx}))) ( - let foldResult = - Lists.foldl (\acc -> \term -> Eithers.bind acc (\accR -> - let types = Pairs.first accR - cxA = Pairs.second accR - in (Eithers.bind (typeOf cxA tx [] term) (\tResult -> - let t = Pairs.first tResult - cxB = Pairs.second tResult - in (Right (Lists.concat2 types (Lists.pure t), cxB)))))) (Right ([], cx)) els - in (Eithers.bind foldResult (\foldR -> - let eltypes = Pairs.first foldR - cx2 = Pairs.second foldR - in (Eithers.bind (checkSameType cx2 tx "list elements" eltypes) (\unifiedType -> Right (Core.TypeList unifiedType, cx2)))))) - --- | Reconstruct the type of a literal (Either/Context version) -typeOfLiteral :: Context.Context -> Graph.Graph -> [Core.Type] -> Core.Literal -> Either (Context.InContext Errors.Error) (Core.Type, Context.Context) -typeOfLiteral cx tx typeArgs lit = - - let t = Core.TypeLiteral (Reflect.literalType lit) - in (Eithers.bind (applyTypeArgumentsToType cx tx typeArgs t) (\applied -> Right (applied, cx))) - --- | Reconstruct the type of a map (Either/Context version) -typeOfMap :: Context.Context -> Graph.Graph -> [Core.Type] -> M.Map Core.Term Core.Term -> Either (Context.InContext Errors.Error) (Core.Type, Context.Context) -typeOfMap cx tx typeArgs m = - Logic.ifElse (Maps.null m) (Logic.ifElse (Equality.equal (Lists.length typeArgs) 2) (Right (Core.TypeMap (Core.MapType { - Core.mapTypeKeys = (Lists.at 0 typeArgs), - Core.mapTypeValues = (Lists.at 1 typeArgs)}), cx)) (Left (Context.InContext { - Context.inContextObject = (Errors.ErrorChecking (Checking.CheckingErrorTypeArityMismatch (Checking.TypeArityMismatchError { - Checking.typeArityMismatchErrorType = (Core.TypeMap (Core.MapType { - Core.mapTypeKeys = Core.TypeUnit, - Core.mapTypeValues = Core.TypeUnit})), - Checking.typeArityMismatchErrorExpectedArity = 2, - Checking.typeArityMismatchErrorActualArity = (Lists.length typeArgs), - Checking.typeArityMismatchErrorTypeArguments = typeArgs}))), - Context.inContextContext = cx}))) ( - let pairs = Maps.toList m - keyFoldResult = - Lists.foldl (\acc -> \p -> Eithers.bind acc (\accR -> - let types = Pairs.first accR - cxA = Pairs.second accR - in (Eithers.bind (typeOf cxA tx [] (Pairs.first p)) (\tResult -> - let t = Pairs.first tResult - cxB = Pairs.second tResult - in (Right (Lists.concat2 types (Lists.pure t), cxB)))))) (Right ([], cx)) pairs - in (Eithers.bind keyFoldResult (\keyFoldR -> - let keyTypes = Pairs.first keyFoldR - cx2 = Pairs.second keyFoldR - in (Eithers.bind (checkSameType cx2 tx "map keys" keyTypes) (\kt -> - let valFoldResult = - Lists.foldl (\acc -> \p -> Eithers.bind acc (\accR -> - let types = Pairs.first accR - cxA = Pairs.second accR - in (Eithers.bind (typeOf cxA tx [] (Pairs.second p)) (\tResult -> - let t = Pairs.first tResult - cxB = Pairs.second tResult - in (Right (Lists.concat2 types (Lists.pure t), cxB)))))) (Right ([], cx2)) pairs - in (Eithers.bind valFoldResult (\valFoldR -> - let valTypes = Pairs.first valFoldR - cx3 = Pairs.second valFoldR - in (Eithers.bind (checkSameType cx3 tx "map values" valTypes) (\vt -> Eithers.bind (applyTypeArgumentsToType cx3 tx typeArgs (Core.TypeMap (Core.MapType { - Core.mapTypeKeys = kt, - Core.mapTypeValues = vt}))) (\applied -> Right (applied, cx3))))))))))) - --- | Reconstruct the type of an optional value (Either/Context version) -typeOfMaybe :: Context.Context -> Graph.Graph -> [Core.Type] -> Maybe Core.Term -> Either (Context.InContext Errors.Error) (Core.Type, Context.Context) -typeOfMaybe cx tx typeArgs mt = - - let forNothing = - - let n = Lists.length typeArgs - in (Logic.ifElse (Equality.equal n 1) (Right (Core.TypeMaybe (Lists.head typeArgs), cx)) (Left (Context.InContext { - Context.inContextObject = (Errors.ErrorChecking (Checking.CheckingErrorTypeArityMismatch (Checking.TypeArityMismatchError { - Checking.typeArityMismatchErrorType = (Core.TypeMaybe Core.TypeUnit), - Checking.typeArityMismatchErrorExpectedArity = 1, - Checking.typeArityMismatchErrorActualArity = n, - Checking.typeArityMismatchErrorTypeArguments = typeArgs}))), - Context.inContextContext = cx}))) - forJust = - \term -> Eithers.bind (typeOf cx tx [] term) (\tResult -> - let termType = Pairs.first tResult - cx2 = Pairs.second tResult - t = Core.TypeMaybe termType - in (Eithers.bind (applyTypeArgumentsToType cx2 tx typeArgs t) (\applied -> Right (applied, cx2)))) - in (Maybes.maybe forNothing forJust mt) - --- | Reconstruct the type of a pair (Either/Context version) -typeOfPair :: Context.Context -> Graph.Graph -> [Core.Type] -> (Core.Term, Core.Term) -> Either (Context.InContext Errors.Error) (Core.Type, Context.Context) -typeOfPair cx tx typeArgs p = - - let n = Lists.length typeArgs - in (Logic.ifElse (Equality.equal n 2) ( - let pairFst = Pairs.first p - pairSnd = Pairs.second p - in (Eithers.bind (typeOf cx tx [] pairFst) (\result1 -> - let firstType = Pairs.first result1 - cx2 = Pairs.second result1 - in (Eithers.bind (typeOf cx2 tx [] pairSnd) (\result2 -> - let secondType = Pairs.first result2 - cx3 = Pairs.second result2 - in (Right (Core.TypePair (Core.PairType { - Core.pairTypeFirst = firstType, - Core.pairTypeSecond = secondType}), cx3))))))) (Left (Context.InContext { - Context.inContextObject = (Errors.ErrorChecking (Checking.CheckingErrorTypeArityMismatch (Checking.TypeArityMismatchError { - Checking.typeArityMismatchErrorType = (Core.TypePair (Core.PairType { - Core.pairTypeFirst = Core.TypeUnit, - Core.pairTypeSecond = Core.TypeUnit})), - Checking.typeArityMismatchErrorExpectedArity = 2, - Checking.typeArityMismatchErrorActualArity = n, - Checking.typeArityMismatchErrorTypeArguments = typeArgs}))), - Context.inContextContext = cx}))) - --- | Reconstruct the type of a primitive function (Either/Context version) -typeOfPrimitive :: Context.Context -> Graph.Graph -> [Core.Type] -> Core.Name -> Either (Context.InContext Errors.Error) (Core.Type, Context.Context) -typeOfPrimitive cx tx typeArgs name = - - let rawTs = Maybes.map (\_p -> Graph.primitiveType _p) (Maps.lookup name (Graph.graphPrimitives tx)) - in (Maybes.maybe (Left (Context.InContext { - Context.inContextObject = (Errors.ErrorUndefinedTermVariable (Core_.UndefinedTermVariableError { - Core_.undefinedTermVariableErrorLocation = (Paths.SubtermPath []), - Core_.undefinedTermVariableErrorName = name})), - Context.inContextContext = cx})) (\tsRaw -> - let instResult = Schemas.instantiateTypeScheme cx tsRaw - ts = Pairs.first instResult - cx2 = Pairs.second instResult - t = Rewriting.typeSchemeToFType ts - in (Eithers.bind (applyTypeArgumentsToType cx2 tx typeArgs t) (\applied -> Right (applied, cx2)))) rawTs) - --- | Reconstruct the type of a record projection (Either/Context version) -typeOfProjection :: Context.Context -> Graph.Graph -> [Core.Type] -> Core.Projection -> Either (Context.InContext Errors.Error) (Core.Type, Context.Context) -typeOfProjection cx tx typeArgs p = - - let tname = Core.projectionTypeName p - fname = Core.projectionField p - in (Eithers.bind (Schemas.requireSchemaType cx (Graph.graphSchemaTypes tx) tname) (\schemaResult -> - let schemaType = Pairs.first schemaResult - cx2 = Pairs.second schemaResult - svars = Core.typeSchemeVariables schemaType - sbody = Core.typeSchemeType schemaType - in (Eithers.bind (Core__.recordType cx2 tname sbody) (\sfields -> Eithers.bind (Schemas.findFieldType cx2 fname sfields) (\ftyp -> - let subst = Typing.TypeSubst (Maps.fromList (Lists.zip svars typeArgs)) - sftyp = Substitution.substInType subst ftyp - in (Right (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Schemas.nominalApplication tname typeArgs), - Core.functionTypeCodomain = sftyp}), cx2))))))) - --- | Reconstruct the type of a record (Either/Context version) -typeOfRecord :: Context.Context -> Graph.Graph -> [Core.Type] -> Core.Record -> Either (Context.InContext Errors.Error) (Core.Type, Context.Context) -typeOfRecord cx tx typeArgs record = - - let tname = Core.recordTypeName record - fields = Core.recordFields record - foldResult = - Lists.foldl (\acc -> \term -> Eithers.bind acc (\accR -> - let types = Pairs.first accR - cxA = Pairs.second accR - in (Eithers.bind (typeOf cxA tx [] term) (\tResult -> - let t = Pairs.first tResult - cxB = Pairs.second tResult - in (Right (Lists.concat2 types (Lists.pure t), cxB)))))) (Right ([], cx)) (Lists.map Core.fieldTerm fields) - in (Eithers.bind foldResult (\foldR -> - let cx2 = Pairs.second foldR - in (Right (Schemas.nominalApplication tname typeArgs, cx2)))) - --- | Reconstruct the type of a set (Either/Context version) -typeOfSet :: Context.Context -> Graph.Graph -> [Core.Type] -> S.Set Core.Term -> Either (Context.InContext Errors.Error) (Core.Type, Context.Context) -typeOfSet cx tx typeArgs els = - Logic.ifElse (Sets.null els) (Logic.ifElse (Equality.equal (Lists.length typeArgs) 1) (Right (Core.TypeSet (Lists.head typeArgs), cx)) (Left (Context.InContext { - Context.inContextObject = (Errors.ErrorChecking (Checking.CheckingErrorTypeArityMismatch (Checking.TypeArityMismatchError { - Checking.typeArityMismatchErrorType = (Core.TypeSet Core.TypeUnit), - Checking.typeArityMismatchErrorExpectedArity = 1, - Checking.typeArityMismatchErrorActualArity = (Lists.length typeArgs), - Checking.typeArityMismatchErrorTypeArguments = typeArgs}))), - Context.inContextContext = cx}))) ( - let foldResult = - Lists.foldl (\acc -> \term -> Eithers.bind acc (\accR -> - let types = Pairs.first accR - cxA = Pairs.second accR - in (Eithers.bind (typeOf cxA tx [] term) (\tResult -> - let t = Pairs.first tResult - cxB = Pairs.second tResult - in (Right (Lists.concat2 types (Lists.pure t), cxB)))))) (Right ([], cx)) (Sets.toList els) - in (Eithers.bind foldResult (\foldR -> - let eltypes = Pairs.first foldR - cx2 = Pairs.second foldR - in (Eithers.bind (checkSameType cx2 tx "set elements" eltypes) (\unifiedType -> Right (Core.TypeSet unifiedType, cx2)))))) - --- | Reconstruct the type of a type application term (Either/Context version) -typeOfTypeApplication :: Context.Context -> Graph.Graph -> [Core.Type] -> Core.TypeApplicationTerm -> Either (Context.InContext Errors.Error) (Core.Type, Context.Context) -typeOfTypeApplication cx tx typeArgs tyapp = - - let body = Core.typeApplicationTermBody tyapp - t = Core.typeApplicationTermType tyapp - in (typeOf cx tx (Lists.cons t typeArgs) body) - --- | Reconstruct the type of a type lambda (type abstraction) term (Either/Context version) -typeOfTypeLambda :: Context.Context -> Graph.Graph -> [Core.Type] -> Core.TypeLambda -> Either (Context.InContext Errors.Error) (Core.Type, Context.Context) -typeOfTypeLambda cx tx typeArgs tl = - - let v = Core.typeLambdaParameter tl - body = Core.typeLambdaBody tl - vars = Graph.graphTypeVariables tx - tx2 = - Graph.Graph { - Graph.graphBoundTerms = (Graph.graphBoundTerms tx), - Graph.graphBoundTypes = (Graph.graphBoundTypes tx), - Graph.graphClassConstraints = (Graph.graphClassConstraints tx), - Graph.graphLambdaVariables = (Graph.graphLambdaVariables tx), - Graph.graphMetadata = (Graph.graphMetadata tx), - Graph.graphPrimitives = (Graph.graphPrimitives tx), - Graph.graphSchemaTypes = (Graph.graphSchemaTypes tx), - Graph.graphTypeVariables = (Sets.insert v vars)} - in (Eithers.bind (typeOf cx tx2 [] body) (\result1 -> - let t1 = Pairs.first result1 - cx2 = Pairs.second result1 - in (Eithers.bind (applyTypeArgumentsToType cx2 tx typeArgs (Core.TypeForall (Core.ForallType { - Core.forallTypeParameter = v, - Core.forallTypeBody = t1}))) (\applied -> Right (applied, cx2))))) - --- | Reconstruct the type of the unit term (Either/Context version) -typeOfUnit :: Context.Context -> Graph.Graph -> [Core.Type] -> Either (Context.InContext Errors.Error) (Core.Type, Context.Context) -typeOfUnit cx tx typeArgs = - Eithers.bind (applyTypeArgumentsToType cx tx typeArgs Core.TypeUnit) (\applied -> Right (applied, cx)) - --- | Reconstruct the type of an unwrap operation (Either/Context version) -typeOfUnwrap :: Context.Context -> Graph.Graph -> [Core.Type] -> Core.Name -> Either (Context.InContext Errors.Error) (Core.Type, Context.Context) -typeOfUnwrap cx tx typeArgs tname = - Eithers.bind (Schemas.requireSchemaType cx (Graph.graphSchemaTypes tx) tname) (\schemaResult -> - let schemaType = Pairs.first schemaResult - cx2 = Pairs.second schemaResult - svars = Core.typeSchemeVariables schemaType - sbody = Core.typeSchemeType schemaType - in (Eithers.bind (Core__.wrappedType cx2 tname sbody) (\wrapped -> - let subst = Typing.TypeSubst (Maps.fromList (Lists.zip svars typeArgs)) - swrapped = Substitution.substInType subst wrapped - in (Right (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Schemas.nominalApplication tname typeArgs), - Core.functionTypeCodomain = swrapped}), cx2))))) - --- | Reconstruct the type of a variable (Either/Context version) -typeOfVariable :: Context.Context -> Graph.Graph -> [Core.Type] -> Core.Name -> Either (Context.InContext Errors.Error) (Core.Type, Context.Context) -typeOfVariable cx tx typeArgs name = - - let rawTypeScheme = Maps.lookup name (Graph.graphBoundTypes tx) - in (Maybes.maybe (Left (Context.InContext { - Context.inContextObject = (Errors.ErrorUntypedTermVariable (Core_.UntypedTermVariableError { - Core_.untypedTermVariableErrorLocation = (Paths.SubtermPath []), - Core_.untypedTermVariableErrorName = name})), - Context.inContextContext = cx})) (\ts -> - let tResult = - Logic.ifElse (Lists.null typeArgs) (Schemas.instantiateType cx (Rewriting.typeSchemeToFType ts)) (Rewriting.typeSchemeToFType ts, cx) - t = Pairs.first tResult - cx2 = Pairs.second tResult - in (Eithers.bind (applyTypeArgumentsToType cx2 tx typeArgs t) (\applied -> Right (applied, cx2)))) rawTypeScheme) - --- | Reconstruct the type of a wrapped term (Either/Context version) -typeOfWrappedTerm :: Context.Context -> Graph.Graph -> [Core.Type] -> Core.WrappedTerm -> Either (Context.InContext Errors.Error) (Core.Type, Context.Context) -typeOfWrappedTerm cx tx typeArgs wt = - - let tname = Core.wrappedTermTypeName wt - body = Core.wrappedTermBody wt - in (Eithers.bind (typeOf cx tx [] body) (\result -> - let cx2 = Pairs.second result - in (Right (Schemas.nominalApplication tname typeArgs, cx2)))) - --- | Check whether a list of types are effectively equal, disregarding type aliases and free type variable naming. Also treats free type variables (not in schema) as wildcards, since inference has already verified consistency. -typesAllEffectivelyEqual :: Graph.Graph -> [Core.Type] -> Bool -typesAllEffectivelyEqual tx tlist = - - let types = Graph.graphSchemaTypes tx - containsFreeVar = - \t -> - let allVars = Rewriting.freeVariablesInTypeSimple t - schemaNames = Sets.fromList (Maps.keys types) - in (Logic.not (Sets.null (Sets.difference allVars schemaNames))) - anyContainsFreeVar = Lists.foldl (\acc -> \t -> Logic.or acc (containsFreeVar t)) False tlist - in (Logic.ifElse anyContainsFreeVar True (Logic.ifElse (allEqual (Lists.map (\t -> normalizeTypeFreeVars t) tlist)) True (allEqual (Lists.map (\t -> normalizeTypeFreeVars (Rewriting.deannotateTypeRecursive (Rewriting.replaceTypedefs types t))) tlist)))) - --- | Check whether two types are effectively equal, disregarding type aliases, forall quantifiers, and treating in-scope type variables as wildcards -typesEffectivelyEqual :: Graph.Graph -> Core.Type -> Core.Type -> Bool -typesEffectivelyEqual tx t1 t2 = - Logic.or (containsInScopeTypeVars tx t1) (Logic.or (containsInScopeTypeVars tx t2) (typesAllEffectivelyEqual tx [ - Schemas.fullyStripAndNormalizeType t1, - (Schemas.fullyStripAndNormalizeType t2)])) diff --git a/src/gen-main/haskell/Hydra/Classes.hs b/src/gen-main/haskell/Hydra/Classes.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Classes.hs +++ /dev/null @@ -1,25 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Type classes - -module Hydra.Classes where - -import qualified Hydra.Core as Core -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | Any of a small number of built-in type classes -data TypeClass = - TypeClassEquality | - TypeClassOrdering - deriving (Eq, Ord, Read, Show) - -_TypeClass = Core.Name "hydra.classes.TypeClass" - -_TypeClass_equality = Core.Name "equality" - -_TypeClass_ordering = Core.Name "ordering" diff --git a/src/gen-main/haskell/Hydra/CodeGeneration.hs b/src/gen-main/haskell/Hydra/CodeGeneration.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/CodeGeneration.hs +++ /dev/null @@ -1,390 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Pure code generation pipeline for bootstrapping Hydra across languages. - -module Hydra.CodeGeneration where - -import qualified Hydra.Adapt as Adapt -import qualified Hydra.Annotations as Annotations -import qualified Hydra.Coders as Coders -import qualified Hydra.Context as Context -import qualified Hydra.Core as Core -import qualified Hydra.Decode.Core as Core_ -import qualified Hydra.Decode.Module as Module -import qualified Hydra.Encode.Module as Module_ -import qualified Hydra.Errors as Errors -import qualified Hydra.Graph as Graph -import qualified Hydra.Inference as Inference -import qualified Hydra.Json.Decode as Decode -import qualified Hydra.Json.Encode as Encode -import qualified Hydra.Json.Model as Model -import qualified Hydra.Json.Writer as Writer -import qualified Hydra.Lexical as Lexical -import qualified Hydra.Lib.Eithers as Eithers -import qualified Hydra.Lib.Equality as Equality -import qualified Hydra.Lib.Lists as Lists -import qualified Hydra.Lib.Logic as Logic -import qualified Hydra.Lib.Maps as Maps -import qualified Hydra.Lib.Math as Math -import qualified Hydra.Lib.Maybes as Maybes -import qualified Hydra.Lib.Pairs as Pairs -import qualified Hydra.Lib.Sets as Sets -import qualified Hydra.Lib.Strings as Strings -import qualified Hydra.Module as Module__ -import qualified Hydra.Rewriting as Rewriting -import qualified Hydra.Schemas as Schemas -import qualified Hydra.Show.Core as Core__ -import qualified Hydra.Show.Errors as Errors_ -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | Build a schema map (Name -> Type) from a graph's schema types -buildSchemaMap :: Graph.Graph -> M.Map Core.Name Core.Type -buildSchemaMap g = Maps.map (\ts -> Rewriting.deannotateType (Core.typeSchemeType ts)) (Graph.graphSchemaTypes g) - --- | Decode a single module from a JSON value -decodeModuleFromJson :: Graph.Graph -> [Module__.Module] -> Bool -> Model.Value -> Either String Module__.Module -decodeModuleFromJson bsGraph universeModules doStripTypeSchemes jsonVal = - - let graph = modulesToGraph bsGraph universeModules universeModules - schemaMap = buildSchemaMap graph - modType = Core.TypeVariable (Core.Name "hydra.module.Module") - in (Eithers.either (\err -> Left err) (\term -> Eithers.either (\decErr -> Left (Errors.unDecodingError decErr)) (\mod -> Right (Logic.ifElse doStripTypeSchemes (stripModuleTypeSchemes mod) mod)) (Module.module_ graph term)) (Decode.fromJson schemaMap (Core.Name "hydra.module.Module") modType jsonVal)) - --- | Escape unescaped control characters inside JSON string literals -escapeControlCharsInJson :: [Int] -> [Int] -escapeControlCharsInJson input = - - let hexDigit = \n -> Logic.ifElse (Equality.lt n 10) (Math.add 48 n) (Math.add 97 (Math.sub n 10)) - escapeToUnicode = - \b -> [ - 92, - 117, - 48, - 48, - (hexDigit (Math.div b 16)), - (hexDigit (Math.mod b 16))] - go = - \inStr -> \esc -> \bytes -> Logic.ifElse (Lists.null bytes) [] ( - let b = Lists.head bytes - bs = Lists.tail bytes - in (Logic.ifElse esc (Lists.cons b (go inStr False bs)) (Logic.ifElse (Logic.and (Equality.equal b 92) inStr) (Lists.cons b (go inStr True bs)) (Logic.ifElse (Equality.equal b 34) (Lists.cons b (go (Logic.not inStr) False bs)) (Logic.ifElse (Logic.and inStr (Equality.lt b 32)) (Lists.concat2 (escapeToUnicode b) (go inStr False bs)) (Lists.cons b (go inStr False bs))))))) - in (go False False input) - --- | Format a primitive for the lexicon -formatPrimitive :: Graph.Primitive -> String -formatPrimitive prim = - - let name = Core.unName (Graph.primitiveName prim) - typeStr = Core__.typeScheme (Graph.primitiveType prim) - in (Strings.cat2 (Strings.cat2 (Strings.cat2 " " name) " : ") typeStr) - --- | Format a term binding for the lexicon -formatTermBinding :: Core.Binding -> String -formatTermBinding binding = - - let name = Core.unName (Core.bindingName binding) - typeStr = Maybes.maybe "?" (\scheme -> Core__.typeScheme scheme) (Core.bindingType binding) - in (Strings.cat2 (Strings.cat2 (Strings.cat2 " " name) " : ") typeStr) - --- | Format a type binding for the lexicon -formatTypeBinding :: Graph.Graph -> Core.Binding -> Either Errors.DecodingError String -formatTypeBinding graph binding = - Eithers.bind (Core_.type_ graph (Core.bindingTerm binding)) (\typ -> Right (Strings.cat2 (Strings.cat2 (Strings.cat2 " " (Core.unName (Core.bindingName binding))) " = ") (Core__.type_ typ))) - --- | Generate encoder or decoder modules for a list of type modules -generateCoderModules :: (t0 -> Graph.Graph -> t1 -> Either t2 (Maybe t3)) -> Graph.Graph -> [Module__.Module] -> [t1] -> t0 -> Either t2 [t3] -generateCoderModules codec bsGraph universeModules typeModules cx = - - let universe = Maps.fromList (Lists.map (\m -> (Module__.moduleNamespace m, m)) (Lists.concat2 universeModules universeModules)) - schemaModules = moduleTypeDepsTransitive universe universeModules - dataModules = moduleTermDepsTransitive universe universeModules - schemaElements = - Lists.concat (Lists.map (\m -> Maybes.cat (Lists.map (\d -> case d of - Module__.DefinitionType v0 -> Just (Annotations.typeElement (Module__.typeDefinitionName v0) (Module__.typeDefinitionType v0)) - _ -> Nothing) (Module__.moduleDefinitions m))) (Lists.concat2 schemaModules universeModules)) - dataElements = - Lists.concat (Lists.map (\m -> Maybes.cat (Lists.map (\d -> case d of - Module__.DefinitionTerm v0 -> Just (Core.Binding { - Core.bindingName = (Module__.termDefinitionName v0), - Core.bindingTerm = (Module__.termDefinitionTerm v0), - Core.bindingType = (Module__.termDefinitionType v0)}) - _ -> Nothing) (Module__.moduleDefinitions m))) dataModules) - schemaGraph = Lexical.elementsToGraph bsGraph Maps.empty schemaElements - schemaTypes = - Eithers.either (\_ -> Maps.empty) (\_r -> _r) (Schemas.schemaGraphToTypingEnvironment Lexical.emptyContext schemaGraph) - allElements = Lists.concat2 schemaElements dataElements - graph = Lexical.elementsToGraph bsGraph schemaTypes allElements - in (Eithers.map (\results -> Maybes.cat results) (Eithers.mapList (\m -> codec cx graph m) typeModules)) - --- | Generate the lexicon content from a graph -generateLexicon :: Graph.Graph -> Either Errors.DecodingError String -generateLexicon graph = - - let bindings = Lexical.graphToBindings graph - primitives = Maps.elems (Graph.graphPrimitives graph) - partitioned = Lists.partition (\b -> Annotations.isNativeType b) bindings - typeBindings = Pairs.first partitioned - termBindings = Pairs.second partitioned - sortedPrimitives = Lists.sortOn (\p -> Graph.primitiveName p) primitives - sortedTypes = Lists.sortOn (\b -> Core.bindingName b) typeBindings - sortedTerms = Lists.sortOn (\b -> Core.bindingName b) termBindings - in (Eithers.bind (Eithers.mapList (\b -> formatTypeBinding graph b) sortedTypes) (\typeLines -> - let termLines = Lists.map (\b -> formatTermBinding b) sortedTerms - primitiveLines = Lists.map (\p -> formatPrimitive p) sortedPrimitives - in (Right (Strings.cat2 (Strings.cat2 (Strings.cat2 (Strings.cat2 (Strings.cat2 "Primitives:\n" (Strings.unlines primitiveLines)) "\nTypes:\n") (Strings.unlines typeLines)) "\nTerms:\n") (Strings.unlines termLines))))) - --- | Pure core of code generation: given a coder, language, flags, bootstrap graph, universe, and modules to generate, produce a list of (filePath, content) pairs. -generateSourceFiles :: Ord t0 => ((Module__.Module -> [Module__.Definition] -> Context.Context -> Graph.Graph -> Either (Context.InContext Errors.Error) (M.Map t0 t1)) -> Coders.Language -> Bool -> Bool -> Bool -> Bool -> Graph.Graph -> [Module__.Module] -> [Module__.Module] -> Context.Context -> Either (Context.InContext Errors.Error) [(t0, t1)]) -generateSourceFiles printDefinitions lang doInfer doExpand doHoistCaseStatements doHoistPolymorphicLetBindings bsGraph universeModules modsToGenerate cx = - - let namespaceMap = - Maps.fromList (Lists.map (\m -> (Module__.moduleNamespace m, m)) (Lists.concat2 universeModules modsToGenerate)) - constraints = Coders.languageConstraints lang - typeModulesToGenerate = - Lists.filter (\mod -> Logic.not (Lists.null (Maybes.cat (Lists.map (\d -> case d of - Module__.DefinitionType v0 -> Just (Annotations.typeElement (Module__.typeDefinitionName v0) (Module__.typeDefinitionType v0)) - _ -> Nothing) (Module__.moduleDefinitions mod))))) modsToGenerate - termModulesToGenerate = - Lists.filter (\mod -> Logic.not (Lists.null (Maybes.cat (Lists.map (\d -> case d of - Module__.DefinitionTerm v0 -> Just (Core.Binding { - Core.bindingName = (Module__.termDefinitionName v0), - Core.bindingTerm = (Module__.termDefinitionTerm v0), - Core.bindingType = (Module__.termDefinitionType v0)}) - _ -> Nothing) (Module__.moduleDefinitions mod))))) modsToGenerate - schemaMods = moduleTypeDepsTransitive namespaceMap modsToGenerate - schemaElements = - Lists.concat (Lists.map (\m -> Maybes.cat (Lists.map (\d -> case d of - Module__.DefinitionType v0 -> Just (Annotations.typeElement (Module__.typeDefinitionName v0) (Module__.typeDefinitionType v0)) - _ -> Nothing) (Module__.moduleDefinitions m))) (Lists.concat2 schemaMods typeModulesToGenerate)) - dataMods = moduleTermDepsTransitive namespaceMap modsToGenerate - dataElements = - Lists.concat (Lists.map (\m -> Maybes.cat (Lists.map (\d -> case d of - Module__.DefinitionTerm v0 -> Just (Core.Binding { - Core.bindingName = (Module__.termDefinitionName v0), - Core.bindingTerm = (Module__.termDefinitionTerm v0), - Core.bindingType = (Module__.termDefinitionType v0)}) - _ -> Nothing) (Module__.moduleDefinitions m))) dataMods) - schemaGraph = Lexical.elementsToGraph bsGraph Maps.empty schemaElements - schemaTypes2 = - Eithers.either (\_ -> Maps.empty) (\_r -> _r) (Schemas.schemaGraphToTypingEnvironment Lexical.emptyContext schemaGraph) - dataGraph = Lexical.elementsToGraph bsGraph schemaTypes2 dataElements - in (Eithers.bind (Logic.ifElse (Lists.null typeModulesToGenerate) (Right []) ( - let nameLists = - Lists.map (\m -> Maybes.cat (Lists.map (\d -> case d of - Module__.DefinitionType v0 -> Just (Module__.typeDefinitionName v0) - _ -> Nothing) (Module__.moduleDefinitions m))) typeModulesToGenerate - in (Eithers.bind (Eithers.bimap (\s -> Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError s)), - Context.inContextContext = cx}) (\r -> r) (Adapt.schemaGraphToDefinitions constraints schemaGraph nameLists cx)) (\schemaResult -> - let defLists = Pairs.second schemaResult - schemaGraphWithTypes = - Graph.Graph { - Graph.graphBoundTerms = (Graph.graphBoundTerms schemaGraph), - Graph.graphBoundTypes = (Graph.graphBoundTypes schemaGraph), - Graph.graphClassConstraints = (Graph.graphClassConstraints schemaGraph), - Graph.graphLambdaVariables = (Graph.graphLambdaVariables schemaGraph), - Graph.graphMetadata = (Graph.graphMetadata schemaGraph), - Graph.graphPrimitives = (Graph.graphPrimitives schemaGraph), - Graph.graphSchemaTypes = schemaTypes2, - Graph.graphTypeVariables = (Graph.graphTypeVariables schemaGraph)} - in (Eithers.map (\xs -> Lists.concat xs) (Eithers.mapList (\p -> - let mod = Pairs.first p - defs = Pairs.second p - in (Eithers.map (\m -> Maps.toList m) (printDefinitions mod (Lists.map (\d -> Module__.DefinitionType d) defs) cx schemaGraphWithTypes))) (Lists.zip typeModulesToGenerate defLists))))))) (\schemaFiles -> Eithers.bind (Logic.ifElse (Lists.null termModulesToGenerate) (Right []) ( - let namespaces = Lists.map (\m -> Module__.moduleNamespace m) termModulesToGenerate - in (Eithers.bind (Eithers.bimap (\s -> Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError s)), - Context.inContextContext = cx}) (\r -> r) (Adapt.dataGraphToDefinitions constraints doInfer doExpand doHoistCaseStatements doHoistPolymorphicLetBindings dataElements dataGraph namespaces cx)) (\dataResult -> - let g1 = Pairs.first dataResult - defLists = Pairs.second dataResult - defName = - \d -> case d of - Module__.DefinitionTerm v0 -> Module__.termDefinitionName v0 - Module__.DefinitionType v0 -> Module__.typeDefinitionName v0 - refreshModule = - \els -> \m -> Module__.Module { - Module__.moduleNamespace = (Module__.moduleNamespace m), - Module__.moduleDefinitions = (Maybes.cat (Lists.map (\d -> case d of - Module__.DefinitionType v0 -> Just (Module__.DefinitionType v0) - Module__.DefinitionTerm v0 -> Maybes.map (\b -> Module__.DefinitionTerm (Module__.TermDefinition { - Module__.termDefinitionName = (Core.bindingName b), - Module__.termDefinitionTerm = (Core.bindingTerm b), - Module__.termDefinitionType = (Core.bindingType b)})) (Lists.find (\b -> Equality.equal (Core.bindingName b) (Module__.termDefinitionName v0)) els)) (Module__.moduleDefinitions m))), - Module__.moduleTermDependencies = (Module__.moduleTermDependencies m), - Module__.moduleTypeDependencies = (Module__.moduleTypeDependencies m), - Module__.moduleDescription = (Module__.moduleDescription m)} - allBindings = Lexical.graphToBindings g1 - refreshedMods = Lists.map (\m -> refreshModule allBindings m) termModulesToGenerate - dedupDefs = \defs -> Maps.elems (Maps.fromList (Lists.map (\d -> (Module__.termDefinitionName d, d)) defs)) - dedupedDefLists = Lists.map dedupDefs defLists - in (Eithers.map (\xs -> Lists.concat xs) (Eithers.mapList (\p -> - let mod = Pairs.first p - defs = Pairs.second p - in (Eithers.map (\m -> Maps.toList m) (printDefinitions mod (Lists.map (\d -> Module__.DefinitionTerm d) defs) cx g1))) (Lists.zip refreshedMods dedupedDefLists))))))) (\termFiles -> Right (Lists.concat2 schemaFiles termFiles)))) - --- | Perform type inference and generate the lexicon for a set of modules -inferAndGenerateLexicon :: Context.Context -> Graph.Graph -> [Module__.Module] -> Either String String -inferAndGenerateLexicon cx bsGraph kernelModules = - - let g0 = modulesToGraph bsGraph kernelModules kernelModules - dataElements = - Lists.concat (Lists.map (\m -> Maybes.cat (Lists.map (\d -> case d of - Module__.DefinitionTerm v0 -> Just (Core.Binding { - Core.bindingName = (Module__.termDefinitionName v0), - Core.bindingTerm = (Module__.termDefinitionTerm v0), - Core.bindingType = (Module__.termDefinitionType v0)}) - _ -> Nothing) (Module__.moduleDefinitions m))) kernelModules) - in (Eithers.bind (Eithers.bimap (\ic -> Errors_.error (Context.inContextObject ic)) (\x -> x) (Inference.inferGraphTypes cx dataElements g0)) (\inferResultWithCx -> - let g1 = Pairs.first (Pairs.first inferResultWithCx) - in (Eithers.bimap Errors.unDecodingError (\x -> x) (generateLexicon g1)))) - --- | Perform type inference on modules and reconstruct with inferred types -inferModules :: Context.Context -> Graph.Graph -> [Module__.Module] -> [Module__.Module] -> Either (Context.InContext Errors.Error) [Module__.Module] -inferModules cx bsGraph universeMods targetMods = - - let g0 = modulesToGraph bsGraph universeMods universeMods - dataElements = - Lists.concat (Lists.map (\m -> Maybes.cat (Lists.map (\d -> case d of - Module__.DefinitionTerm v0 -> Just (Core.Binding { - Core.bindingName = (Module__.termDefinitionName v0), - Core.bindingTerm = (Module__.termDefinitionTerm v0), - Core.bindingType = (Module__.termDefinitionType v0)}) - _ -> Nothing) (Module__.moduleDefinitions m))) universeMods) - in (Eithers.bind (Inference.inferGraphTypes cx dataElements g0) (\inferResultWithCx -> - let inferResult = Pairs.first inferResultWithCx - g1 = Pairs.first inferResult - inferredElements = Pairs.second inferResult - isTypeOnlyModule = - \mod -> Logic.not (Logic.not (Lists.null (Maybes.cat (Lists.map (\d -> case d of - Module__.DefinitionTerm v0 -> Just (Core.Binding { - Core.bindingName = (Module__.termDefinitionName v0), - Core.bindingTerm = (Module__.termDefinitionTerm v0), - Core.bindingType = (Module__.termDefinitionType v0)}) - _ -> Nothing) (Module__.moduleDefinitions mod))))) - defName = - \d -> case d of - Module__.DefinitionTerm v0 -> Module__.termDefinitionName v0 - Module__.DefinitionType v0 -> Module__.typeDefinitionName v0 - refreshModule = - \m -> Logic.ifElse (isTypeOnlyModule m) m (Module__.Module { - Module__.moduleNamespace = (Module__.moduleNamespace m), - Module__.moduleDefinitions = (Maybes.cat (Lists.map (\d -> case d of - Module__.DefinitionType v0 -> Just (Module__.DefinitionType v0) - Module__.DefinitionTerm v0 -> Maybes.map (\b -> Module__.DefinitionTerm (Module__.TermDefinition { - Module__.termDefinitionName = (Core.bindingName b), - Module__.termDefinitionTerm = (Core.bindingTerm b), - Module__.termDefinitionType = (Core.bindingType b)})) (Lists.find (\b -> Equality.equal (Core.bindingName b) (Module__.termDefinitionName v0)) inferredElements)) (Module__.moduleDefinitions m))), - Module__.moduleTermDependencies = (Module__.moduleTermDependencies m), - Module__.moduleTypeDependencies = (Module__.moduleTypeDependencies m), - Module__.moduleDescription = (Module__.moduleDescription m)}) - in (Right (Lists.map refreshModule targetMods)))) - --- | Compute transitive closure of term dependencies for a set of modules -moduleTermDepsTransitive :: M.Map Module__.Namespace Module__.Module -> [Module__.Module] -> [Module__.Module] -moduleTermDepsTransitive nsMap modules = - - let closure = - Sets.union (transitiveDeps (\m -> Module__.moduleTermDependencies m) nsMap modules) (Sets.fromList (Lists.map (\m -> Module__.moduleNamespace m) modules)) - in (Maybes.cat (Lists.map (\n -> Maps.lookup n nsMap) (Sets.toList closure))) - --- | Convert a Module to a JSON string -moduleToJson :: Module__.Module -> Either String String -moduleToJson m = - - let term = Module_.module_ m - in (Eithers.map (\json -> Writer.printJson json) (Encode.toJson term)) - --- | Convert a generated Module into a Source module -moduleToSourceModule :: Module__.Module -> Module__.Module -moduleToSourceModule m = - - let sourceNs = - Module__.Namespace (Strings.cat2 "hydra.sources." (Strings.intercalate "." (Lists.drop 1 (Strings.splitOn "." (Module__.unNamespace (Module__.moduleNamespace m)))))) - modTypeNs = Module__.Namespace "hydra.module" - moduleDef = - Module__.DefinitionTerm (Module__.TermDefinition { - Module__.termDefinitionName = (Core.Name (Strings.cat2 (Module__.unNamespace sourceNs) ".module_")), - Module__.termDefinitionTerm = (Module_.module_ m), - Module__.termDefinitionType = Nothing}) - in Module__.Module { - Module__.moduleNamespace = sourceNs, - Module__.moduleDefinitions = [ - moduleDef], - Module__.moduleTermDependencies = [ - modTypeNs], - Module__.moduleTypeDependencies = [ - modTypeNs], - Module__.moduleDescription = (Just (Strings.cat2 "Source module for " (Module__.unNamespace (Module__.moduleNamespace m))))} - --- | Compute transitive closure of type dependencies for a set of modules -moduleTypeDepsTransitive :: M.Map Module__.Namespace Module__.Module -> [Module__.Module] -> [Module__.Module] -moduleTypeDepsTransitive nsMap modules = - - let termMods = moduleTermDepsTransitive nsMap modules - typeNamespaces = Sets.toList (transitiveDeps (\m -> Module__.moduleTypeDependencies m) nsMap termMods) - in (Maybes.cat (Lists.map (\n -> Maps.lookup n nsMap) typeNamespaces)) - --- | Build a graph from universe modules and working modules, using an explicit bootstrap graph -modulesToGraph :: Graph.Graph -> [Module__.Module] -> [Module__.Module] -> Graph.Graph -modulesToGraph bsGraph universeModules modules = - - let universe = Maps.fromList (Lists.map (\m -> (Module__.moduleNamespace m, m)) (Lists.concat2 universeModules modules)) - schemaModules = moduleTypeDepsTransitive universe modules - dataModules = moduleTermDepsTransitive universe modules - schemaElements = - Lists.concat (Lists.map (\m -> Maybes.cat (Lists.map (\d -> case d of - Module__.DefinitionType v0 -> Just (Annotations.typeElement (Module__.typeDefinitionName v0) (Module__.typeDefinitionType v0)) - _ -> Nothing) (Module__.moduleDefinitions m))) (Lists.concat2 schemaModules modules)) - dataElements = - Lists.concat (Lists.map (\m -> Maybes.cat (Lists.map (\d -> case d of - Module__.DefinitionTerm v0 -> Just (Core.Binding { - Core.bindingName = (Module__.termDefinitionName v0), - Core.bindingTerm = (Module__.termDefinitionTerm v0), - Core.bindingType = (Module__.termDefinitionType v0)}) - _ -> Nothing) (Module__.moduleDefinitions m))) dataModules) - schemaGraph = Lexical.elementsToGraph bsGraph Maps.empty schemaElements - schemaTypes = - Eithers.either (\_ -> Maps.empty) (\_r -> _r) (Schemas.schemaGraphToTypingEnvironment Lexical.emptyContext schemaGraph) - in (Lexical.elementsToGraph bsGraph schemaTypes dataElements) - --- | Convert a namespace to a file path (e.g., hydra.core -> hydra/core) -namespaceToPath :: Module__.Namespace -> String -namespaceToPath ns = Strings.intercalate "/" (Strings.splitOn "." (Module__.unNamespace ns)) - --- | Strip TypeSchemes from term definitions in a module, preserving type definitions. JSON-loaded modules carry inferred TypeSchemes from the original compilation. After adaptation (e.g., bigfloat -> float64), these TypeSchemes become stale and can cause inference errors. Stripping them allows the inference engine to reconstruct correct TypeSchemes from scratch. -stripModuleTypeSchemes :: Module__.Module -> Module__.Module -stripModuleTypeSchemes m = - - let stripDef = - \d -> case d of - Module__.DefinitionTerm v0 -> Module__.DefinitionTerm (Module__.TermDefinition { - Module__.termDefinitionName = (Module__.termDefinitionName v0), - Module__.termDefinitionTerm = (Module__.termDefinitionTerm v0), - Module__.termDefinitionType = Nothing}) - _ -> d - in Module__.Module { - Module__.moduleNamespace = (Module__.moduleNamespace m), - Module__.moduleDefinitions = (Lists.map stripDef (Module__.moduleDefinitions m)), - Module__.moduleTermDependencies = (Module__.moduleTermDependencies m), - Module__.moduleTypeDependencies = (Module__.moduleTypeDependencies m), - Module__.moduleDescription = (Module__.moduleDescription m)} - --- | Compute transitive closure of module dependencies -transitiveDeps :: (Module__.Module -> [Module__.Namespace]) -> M.Map Module__.Namespace Module__.Module -> [Module__.Module] -> S.Set Module__.Namespace -transitiveDeps getDeps nsMap startMods = - - let initialDeps = - Sets.fromList (Lists.concat (Lists.map (\m -> Lists.filter (\dep -> Logic.not (Equality.equal dep (Module__.moduleNamespace m))) (getDeps m)) startMods)) - go = - \pending -> \visited -> Logic.ifElse (Sets.null pending) visited ( - let newVisited = Sets.union visited pending - nextDeps = - Sets.fromList (Lists.concat (Lists.map (\nsv -> Maybes.maybe [] (\depMod -> getDeps depMod) (Maps.lookup nsv nsMap)) (Sets.toList pending))) - newPending = Sets.difference nextDeps newVisited - in (go newPending newVisited)) - in (go initialDeps Sets.empty) diff --git a/src/gen-main/haskell/Hydra/CoderUtils.hs b/src/gen-main/haskell/Hydra/CoderUtils.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/CoderUtils.hs +++ /dev/null @@ -1,332 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Common utilities for language coders, providing shared patterns for term decomposition and analysis. - -module Hydra.CoderUtils where - -import qualified Hydra.Annotations as Annotations -import qualified Hydra.Arity as Arity -import qualified Hydra.Checking as Checking -import qualified Hydra.Coders as Coders -import qualified Hydra.Context as Context -import qualified Hydra.Core as Core -import qualified Hydra.Errors as Errors -import qualified Hydra.Formatting as Formatting -import qualified Hydra.Graph as Graph -import qualified Hydra.Lib.Eithers as Eithers -import qualified Hydra.Lib.Equality as Equality -import qualified Hydra.Lib.Lists as Lists -import qualified Hydra.Lib.Logic as Logic -import qualified Hydra.Lib.Maps as Maps -import qualified Hydra.Lib.Math as Math -import qualified Hydra.Lib.Maybes as Maybes -import qualified Hydra.Lib.Pairs as Pairs -import qualified Hydra.Lib.Sets as Sets -import qualified Hydra.Lib.Strings as Strings -import qualified Hydra.Module as Module -import qualified Hydra.Names as Names -import qualified Hydra.Rewriting as Rewriting -import qualified Hydra.Schemas as Schemas -import qualified Hydra.Sorting as Sorting -import qualified Hydra.Typing as Typing -import qualified Hydra.Util as Util -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | Analyze a function term, collecting lambdas, type lambdas, lets, and type applications -analyzeFunctionTerm :: Context.Context -> (t0 -> Graph.Graph) -> (Graph.Graph -> t0 -> t0) -> t0 -> Core.Term -> Either t1 (Typing.FunctionStructure t0) -analyzeFunctionTerm cx getTC setTC env term = analyzeFunctionTermWith cx bindingMetadata getTC setTC env term - --- | Analyze a function term with configurable binding metadata -analyzeFunctionTermWith :: Context.Context -> (Graph.Graph -> Core.Binding -> Maybe Core.Term) -> (t0 -> Graph.Graph) -> (Graph.Graph -> t0 -> t0) -> t0 -> Core.Term -> Either t1 (Typing.FunctionStructure t0) -analyzeFunctionTermWith cx forBinding getTC setTC env term = - analyzeFunctionTermWith_gather cx forBinding getTC setTC True env [] [] [] [] [] term - -analyzeFunctionTermWith_finish :: Context.Context -> (t0 -> Graph.Graph) -> t0 -> [Core.Name] -> [Core.Name] -> [Core.Binding] -> [Core.Type] -> [Core.Type] -> Core.Term -> Either t1 (Typing.FunctionStructure t0) -analyzeFunctionTermWith_finish cx getTC fEnv tparams args bindings doms tapps body = - - let bodyWithTapps = - Lists.foldl (\trm -> \typ -> Core.TermTypeApplication (Core.TypeApplicationTerm { - Core.typeApplicationTermBody = trm, - Core.typeApplicationTermType = typ})) body tapps - mcod = Eithers.either (\_ -> Nothing) (\c -> Just c) (typeOfTerm cx (getTC fEnv) bodyWithTapps) - in (Right (Typing.FunctionStructure { - Typing.functionStructureTypeParams = (Lists.reverse tparams), - Typing.functionStructureParams = (Lists.reverse args), - Typing.functionStructureBindings = bindings, - Typing.functionStructureBody = bodyWithTapps, - Typing.functionStructureDomains = (Lists.reverse doms), - Typing.functionStructureCodomain = mcod, - Typing.functionStructureEnvironment = fEnv})) - -analyzeFunctionTermWith_gather :: Context.Context -> (Graph.Graph -> Core.Binding -> Maybe Core.Term) -> (t0 -> Graph.Graph) -> (Graph.Graph -> t0 -> t0) -> Bool -> t0 -> [Core.Name] -> [Core.Name] -> [Core.Binding] -> [Core.Type] -> [Core.Type] -> Core.Term -> Either t1 (Typing.FunctionStructure t0) -analyzeFunctionTermWith_gather cx forBinding getTC setTC argMode gEnv tparams args bindings doms tapps t = - case (Rewriting.deannotateTerm t) of - Core.TermFunction v0 -> case v0 of - Core.FunctionLambda v1 -> Logic.ifElse argMode ( - let v = Core.lambdaParameter v1 - dom = Maybes.maybe (Core.TypeVariable (Core.Name "_")) (\x_ -> x_) (Core.lambdaDomain v1) - body = Core.lambdaBody v1 - newEnv = setTC (Rewriting.extendGraphForLambda (getTC gEnv) v1) gEnv - in (analyzeFunctionTermWith_gather cx forBinding getTC setTC argMode newEnv tparams (Lists.cons v args) bindings (Lists.cons dom doms) tapps body)) (analyzeFunctionTermWith_finish cx getTC gEnv tparams args bindings doms tapps t) - _ -> analyzeFunctionTermWith_finish cx getTC gEnv tparams args bindings doms tapps t - Core.TermLet v0 -> - let newBindings = Core.letBindings v0 - body = Core.letBody v0 - newEnv = setTC (Rewriting.extendGraphForLet forBinding (getTC gEnv) v0) gEnv - in (analyzeFunctionTermWith_gather cx forBinding getTC setTC False newEnv tparams args (Lists.concat2 bindings newBindings) doms tapps body) - Core.TermTypeApplication v0 -> - let taBody = Core.typeApplicationTermBody v0 - typ = Core.typeApplicationTermType v0 - in (analyzeFunctionTermWith_gather cx forBinding getTC setTC argMode gEnv tparams args bindings doms (Lists.cons typ tapps) taBody) - Core.TermTypeLambda v0 -> - let tvar = Core.typeLambdaParameter v0 - tlBody = Core.typeLambdaBody v0 - newEnv = setTC (Rewriting.extendGraphForTypeLambda (getTC gEnv) v0) gEnv - in (analyzeFunctionTermWith_gather cx forBinding getTC setTC argMode newEnv (Lists.cons tvar tparams) args bindings doms tapps tlBody) - _ -> analyzeFunctionTermWith_finish cx getTC gEnv tparams args bindings doms tapps t - --- | Produces metadata for a binding if it is complex -bindingMetadata :: Graph.Graph -> Core.Binding -> Maybe Core.Term -bindingMetadata tc b = Logic.ifElse (isComplexBinding tc b) (Just (Core.TermLiteral (Core.LiteralBoolean True))) Nothing - --- | Extract comments/description from a Binding -commentsFromBinding :: Context.Context -> Graph.Graph -> Core.Binding -> Either (Context.InContext Errors.Error) (Maybe String) -commentsFromBinding cx g b = Annotations.getTermDescription cx g (Core.bindingTerm b) - --- | Extract comments/description from a FieldType -commentsFromFieldType :: Context.Context -> Graph.Graph -> Core.FieldType -> Either (Context.InContext Errors.Error) (Maybe String) -commentsFromFieldType cx g ft = Annotations.getTypeDescription cx g (Core.fieldTypeType ft) - --- | Gather applications from a term, returning (args, baseTerm) -gatherApplications :: Core.Term -> ([Core.Term], Core.Term) -gatherApplications term = - - let go = - \args -> \t -> case (Rewriting.deannotateTerm t) of - Core.TermApplication v0 -> - let lhs = Core.applicationFunction v0 - rhs = Core.applicationArgument v0 - in (go (Lists.cons rhs args) lhs) - _ -> (args, t) - in (go [] term) - --- | Gather term arguments, stripping type-level constructs -gatherArgs :: Core.Term -> [Core.Term] -> (Core.Term, [Core.Term]) -gatherArgs term args = - case (Rewriting.deannotateTerm term) of - Core.TermApplication v0 -> - let lhs = Core.applicationFunction v0 - rhs = Core.applicationArgument v0 - in (gatherArgs lhs (Lists.cons rhs args)) - Core.TermTypeLambda v0 -> - let body = Core.typeLambdaBody v0 - in (gatherArgs body args) - Core.TermTypeApplication v0 -> - let body = Core.typeApplicationTermBody v0 - in (gatherArgs body args) - _ -> (term, args) - --- | Gather term and type arguments from a term -gatherArgsWithTypeApps :: Core.Term -> [Core.Term] -> [Core.Type] -> (Core.Term, ([Core.Term], [Core.Type])) -gatherArgsWithTypeApps term args tyArgs = - case (Rewriting.deannotateTerm term) of - Core.TermApplication v0 -> - let lhs = Core.applicationFunction v0 - rhs = Core.applicationArgument v0 - in (gatherArgsWithTypeApps lhs (Lists.cons rhs args) tyArgs) - Core.TermTypeLambda v0 -> - let body = Core.typeLambdaBody v0 - in (gatherArgsWithTypeApps body args tyArgs) - Core.TermTypeApplication v0 -> - let body = Core.typeApplicationTermBody v0 - typ = Core.typeApplicationTermType v0 - in (gatherArgsWithTypeApps body args (Lists.cons typ tyArgs)) - _ -> (term, (args, tyArgs)) - --- | Check if a binding needs to be treated as a function -isComplexBinding :: Graph.Graph -> Core.Binding -> Bool -isComplexBinding tc b = - - let term = Core.bindingTerm b - mts = Core.bindingType b - in (Maybes.cases mts (isComplexTerm tc term) (\ts -> - let isPolymorphic = Logic.not (Lists.null (Core.typeSchemeVariables ts)) - isNonNullary = Equality.gt (Arity.typeArity (Core.typeSchemeType ts)) 0 - isComplex = isComplexTerm tc term - in (Logic.or (Logic.or isPolymorphic isNonNullary) isComplex))) - --- | Check if a term needs to be treated as a function rather than a simple value -isComplexTerm :: Graph.Graph -> Core.Term -> Bool -isComplexTerm tc t = - case t of - Core.TermLet _ -> True - Core.TermTypeApplication _ -> True - Core.TermTypeLambda _ -> True - Core.TermVariable v0 -> isComplexVariable tc v0 - _ -> Lists.foldl (\b -> \sub -> Logic.or b (isComplexTerm tc sub)) False (Rewriting.subterms t) - --- | Check if a variable is bound to a complex term -isComplexVariable :: Graph.Graph -> Core.Name -> Bool -isComplexVariable tc name = - - let metaLookup = Maps.lookup name (Graph.graphMetadata tc) - in (Logic.ifElse (Maybes.isJust metaLookup) True (Logic.ifElse (Sets.member name (Graph.graphLambdaVariables tc)) True ( - let typeLookup = Maps.lookup name (Graph.graphBoundTypes tc) - in (Maybes.maybe True (\ts -> Equality.gt (Arity.typeSchemeArity ts) 0) typeLookup)))) - --- | Check if a term body is self-tail-recursive with respect to a function name -isSelfTailRecursive :: Core.Name -> Core.Term -> Bool -isSelfTailRecursive funcName body = - - let callsSelf = Logic.not (Rewriting.isFreeVariableInTerm funcName body) - in (Logic.ifElse callsSelf (isTailRecursiveInTailPosition funcName body) False) - --- | Check if a term can be encoded as a simple assignment -isSimpleAssignment :: Core.Term -> Bool -isSimpleAssignment term = - case term of - Core.TermAnnotated v0 -> isSimpleAssignment (Core.annotatedTermBody v0) - Core.TermFunction v0 -> case v0 of - Core.FunctionLambda _ -> False - _ -> True - Core.TermLet _ -> False - Core.TermTypeLambda _ -> False - Core.TermTypeApplication v0 -> isSimpleAssignment (Core.typeApplicationTermBody v0) - _ -> - let baseTerm = Pairs.first (gatherArgs term []) - in case baseTerm of - Core.TermFunction v0 -> case v0 of - Core.FunctionElimination v1 -> case v1 of - Core.EliminationUnion _ -> False - _ -> True - _ -> True - _ -> True - --- | Check that all self-references are in tail position -isTailRecursiveInTailPosition :: Core.Name -> Core.Term -> Bool -isTailRecursiveInTailPosition funcName term = - - let stripped = Rewriting.deannotateAndDetypeTerm term - in case stripped of - Core.TermApplication _ -> - let gathered = gatherApplications stripped - gatherArgs = Pairs.first gathered - gatherFun = Pairs.second gathered - strippedFun = Rewriting.deannotateAndDetypeTerm gatherFun - in case strippedFun of - Core.TermVariable v1 -> Logic.ifElse (Equality.equal v1 funcName) ( - let argsNoFunc = Lists.foldl (\ok -> \arg -> Logic.and ok (Rewriting.isFreeVariableInTerm funcName arg)) True gatherArgs - argsNoLambda = - Lists.foldl (\ok -> \arg -> Logic.and ok (Logic.not (Rewriting.foldOverTerm Coders.TraversalOrderPre (\found -> \t -> Logic.or found (case t of - Core.TermFunction v2 -> case v2 of - Core.FunctionLambda v3 -> - let ignore = Core.lambdaBody v3 - in True - _ -> False - _ -> False)) False arg))) True gatherArgs - in (Logic.and argsNoFunc argsNoLambda)) (Rewriting.isFreeVariableInTerm funcName term) - Core.TermFunction v1 -> case v1 of - Core.FunctionElimination v2 -> case v2 of - Core.EliminationUnion v3 -> - let cases_ = Core.caseStatementCases v3 - dflt = Core.caseStatementDefault v3 - branchesOk = - Lists.foldl (\ok -> \field -> Logic.and ok (isTailRecursiveInTailPosition funcName (Core.fieldTerm field))) True cases_ - dfltOk = Maybes.maybe True (\d -> isTailRecursiveInTailPosition funcName d) dflt - argsOk = Lists.foldl (\ok -> \arg -> Logic.and ok (Rewriting.isFreeVariableInTerm funcName arg)) True gatherArgs - in (Logic.and (Logic.and branchesOk dfltOk) argsOk) - _ -> Rewriting.isFreeVariableInTerm funcName term - _ -> Rewriting.isFreeVariableInTerm funcName term - _ -> Rewriting.isFreeVariableInTerm funcName term - Core.TermFunction v0 -> case v0 of - Core.FunctionLambda v1 -> isTailRecursiveInTailPosition funcName (Core.lambdaBody v1) - _ -> Rewriting.isFreeVariableInTerm funcName term - Core.TermLet v0 -> - let bindingsOk = - Lists.foldl (\ok -> \b -> Logic.and ok (Rewriting.isFreeVariableInTerm funcName (Core.bindingTerm b))) True (Core.letBindings v0) - in (Logic.and bindingsOk (isTailRecursiveInTailPosition funcName (Core.letBody v0))) - _ -> Rewriting.isFreeVariableInTerm funcName term - --- | Check if a term is trivially cheap (no thunking needed) -isTrivialTerm :: Core.Term -> Bool -isTrivialTerm t = - case (Rewriting.deannotateTerm t) of - Core.TermLiteral _ -> True - Core.TermVariable _ -> True - Core.TermUnit -> True - Core.TermApplication v0 -> - let fun = Core.applicationFunction v0 - arg = Core.applicationArgument v0 - in case fun of - Core.TermFunction v1 -> case v1 of - Core.FunctionElimination v2 -> case v2 of - Core.EliminationRecord _ -> isTrivialTerm arg - Core.EliminationWrap _ -> isTrivialTerm arg - _ -> False - _ -> False - _ -> False - Core.TermMaybe v0 -> Maybes.maybe True (\inner -> isTrivialTerm inner) v0 - Core.TermRecord v0 -> Lists.foldl (\acc -> \fld -> Logic.and acc (isTrivialTerm (Core.fieldTerm fld))) True (Core.recordFields v0) - Core.TermWrap v0 -> isTrivialTerm (Core.wrappedTermBody v0) - Core.TermTypeApplication v0 -> isTrivialTerm (Core.typeApplicationTermBody v0) - Core.TermTypeLambda v0 -> isTrivialTerm (Core.typeLambdaBody v0) - _ -> False - --- | Convert a name to file path, given case conventions for namespaces and local names, and assuming '/' as the file path separator -nameToFilePath :: Util.CaseConvention -> Util.CaseConvention -> Module.FileExtension -> Core.Name -> String -nameToFilePath nsConv localConv ext name = - - let qualName = Names.qualifyName name - ns = Module.qualifiedNameNamespace qualName - local = Module.qualifiedNameLocal qualName - nsToFilePath = - \ns -> Strings.intercalate "/" (Lists.map (\part -> Formatting.convertCase Util.CaseConventionCamel nsConv part) (Strings.splitOn "." (Module.unNamespace ns))) - prefix = Maybes.maybe "" (\n -> Strings.cat2 (nsToFilePath n) "/") ns - suffix = Formatting.convertCase Util.CaseConventionPascal localConv local - in (Strings.cat [ - prefix, - suffix, - ".", - (Module.unFileExtension ext)]) - --- | Normalize a comment string for consistent output across coders -normalizeComment :: String -> String -normalizeComment s = - - let stripped = Formatting.stripLeadingAndTrailingWhitespace s - in (Logic.ifElse (Strings.null stripped) "" ( - let lastIdx = Math.sub (Strings.length stripped) 1 - lastChar = Strings.charAt lastIdx stripped - in (Logic.ifElse (Equality.equal lastChar 46) stripped (Strings.cat2 stripped ".")))) - --- | Reorder definitions: types first (with hydra.core.Name first among types), then topologically sorted terms -reorderDefs :: [Module.Definition] -> [Module.Definition] -reorderDefs defs = - - let partitioned = Schemas.partitionDefinitions defs - typeDefsRaw = Pairs.first partitioned - nameFirst = Lists.filter (\td -> Equality.equal (Module.typeDefinitionName td) (Core.Name "hydra.core.Name")) typeDefsRaw - nameRest = - Lists.filter (\td -> Logic.not (Equality.equal (Module.typeDefinitionName td) (Core.Name "hydra.core.Name"))) typeDefsRaw - typeDefs = - Lists.concat [ - Lists.map (\td -> Module.DefinitionType td) nameFirst, - (Lists.map (\td -> Module.DefinitionType td) nameRest)] - termDefsWrapped = Lists.map (\td -> Module.DefinitionTerm td) (Pairs.second partitioned) - sortedTermDefs = - Lists.concat (Sorting.topologicalSortNodes (\d -> case d of - Module.DefinitionTerm v0 -> Module.termDefinitionName v0) (\d -> case d of - Module.DefinitionTerm v0 -> Sets.toList (Rewriting.freeVariablesInTerm (Module.termDefinitionTerm v0)) - _ -> []) termDefsWrapped) - in (Lists.concat [ - typeDefs, - sortedTermDefs]) - --- | Check the type of a term -typeOfTerm :: Context.Context -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) Core.Type -typeOfTerm cx g term = Eithers.map Pairs.first (Checking.typeOf cx g [] term) diff --git a/src/gen-main/haskell/Hydra/Coders.hs b/src/gen-main/haskell/Hydra/Coders.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Coders.hs +++ /dev/null @@ -1,130 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Abstractions for paired transformations between languages - -module Hydra.Coders where - -import qualified Hydra.Core as Core -import qualified Hydra.Graph as Graph -import qualified Hydra.Util as Util -import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | An evaluation context together with a source language and a target language -data AdapterContext = - AdapterContext { - -- | The underlying graph of elements and primitives - adapterContextGraph :: Graph.Graph, - -- | The language being encoded or decoded - adapterContextLanguage :: Language, - -- | A map of type names to adapters for those types - adapterContextAdapters :: (M.Map Core.Name (Util.Adapter Core.Type Core.Type Core.Term Core.Term))} - -_AdapterContext = Core.Name "hydra.coders.AdapterContext" - -_AdapterContext_graph = Core.Name "graph" - -_AdapterContext_language = Core.Name "language" - -_AdapterContext_adapters = Core.Name "adapters" - --- | Indicates either the 'out' or the 'in' direction of a coder -data CoderDirection = - CoderDirectionEncode | - CoderDirectionDecode - deriving (Eq, Ord, Read, Show) - -_CoderDirection = Core.Name "hydra.coders.CoderDirection" - -_CoderDirection_encode = Core.Name "encode" - -_CoderDirection_decode = Core.Name "decode" - --- | A named language together with language-specific constraints -data Language = - Language { - -- | The unique name of the language - languageName :: LanguageName, - -- | The constraints which characterize the language - languageConstraints :: LanguageConstraints} - -_Language = Core.Name "hydra.coders.Language" - -_Language_name = Core.Name "name" - -_Language_constraints = Core.Name "constraints" - --- | A set of constraints on valid type and term expressions, characterizing a language -data LanguageConstraints = - LanguageConstraints { - -- | All supported elimination variants - languageConstraintsEliminationVariants :: (S.Set Variants.EliminationVariant), - -- | All supported literal variants - languageConstraintsLiteralVariants :: (S.Set Variants.LiteralVariant), - -- | All supported float types - languageConstraintsFloatTypes :: (S.Set Core.FloatType), - -- | All supported function variants - languageConstraintsFunctionVariants :: (S.Set Variants.FunctionVariant), - -- | All supported integer types - languageConstraintsIntegerTypes :: (S.Set Core.IntegerType), - -- | All supported term variants - languageConstraintsTermVariants :: (S.Set Variants.TermVariant), - -- | All supported type variants - languageConstraintsTypeVariants :: (S.Set Variants.TypeVariant), - -- | A logical set of types, as a predicate which tests a type for inclusion - languageConstraintsTypes :: (Core.Type -> Bool)} - -_LanguageConstraints = Core.Name "hydra.coders.LanguageConstraints" - -_LanguageConstraints_eliminationVariants = Core.Name "eliminationVariants" - -_LanguageConstraints_literalVariants = Core.Name "literalVariants" - -_LanguageConstraints_floatTypes = Core.Name "floatTypes" - -_LanguageConstraints_functionVariants = Core.Name "functionVariants" - -_LanguageConstraints_integerTypes = Core.Name "integerTypes" - -_LanguageConstraints_termVariants = Core.Name "termVariants" - -_LanguageConstraints_typeVariants = Core.Name "typeVariants" - -_LanguageConstraints_types = Core.Name "types" - --- | The unique name of a language -newtype LanguageName = - LanguageName { - unLanguageName :: String} - deriving (Eq, Ord, Read, Show) - -_LanguageName = Core.Name "hydra.coders.LanguageName" - --- | A bidirectional encoder which maps between the same type and term languages on either side -type SymmetricAdapter t v = (Util.Adapter t t v v) - -_SymmetricAdapter = Core.Name "hydra.coders.SymmetricAdapter" - --- | Specifies either a pre-order or post-order traversal -data TraversalOrder = - -- | Pre-order traversal - TraversalOrderPre | - -- | Post-order traversal - TraversalOrderPost - deriving (Eq, Ord, Read, Show) - -_TraversalOrder = Core.Name "hydra.coders.TraversalOrder" - -_TraversalOrder_pre = Core.Name "pre" - -_TraversalOrder_post = Core.Name "post" - --- | A function which maps a Hydra type to a symmetric adapter between types and terms -type TypeAdapter = (AdapterContext -> Core.Type -> Either String (SymmetricAdapter Core.Type Core.Term)) - -_TypeAdapter = Core.Name "hydra.coders.TypeAdapter" diff --git a/src/gen-main/haskell/Hydra/Constants.hs b/src/gen-main/haskell/Hydra/Constants.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Constants.hs +++ /dev/null @@ -1,77 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | A module for tier-0 constants. - -module Hydra.Constants where - -import qualified Hydra.Core as Core -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | Disable type checking by default, for better performance -debugInference :: Bool -debugInference = True - --- | The name used for ignored variables -ignoredVariable :: String -ignoredVariable = "_" - --- | Annotation key for type classes -key_classes :: Core.Name -key_classes = Core.Name "classes" - --- | Annotation key for debug identifiers -key_debugId :: Core.Name -key_debugId = Core.Name "debugId" - --- | Annotation key for deprecated markers -key_deprecated :: Core.Name -key_deprecated = Core.Name "deprecated" - --- | Annotation key for descriptions -key_description :: Core.Name -key_description = Core.Name "description" - --- | Annotation key for exclusions -key_exclude :: Core.Name -key_exclude = Core.Name "exclude" - --- | A flag which tells the language coders to encode a given encoded type as a term rather than a native type -key_firstClassType :: Core.Name -key_firstClassType = Core.Name "firstClassType" - --- | A counter for generating fresh type variable names -key_freshTypeVariableCount :: Core.Name -key_freshTypeVariableCount = Core.Name "freshTypeVariableCount" - --- | Annotation key for maximum length constraints -key_maxLength :: Core.Name -key_maxLength = Core.Name "maxLength" - --- | Annotation key for minimum length constraints -key_minLength :: Core.Name -key_minLength = Core.Name "minLength" - --- | Annotation key for preserving field names during code generation -key_preserveFieldName :: Core.Name -key_preserveFieldName = Core.Name "preserveFieldName" - --- | Annotation key for type information -key_type :: Core.Name -key_type = Core.Name "type" - --- | The maximum value of a 32-bit integer -maxInt32 :: Int -maxInt32 = 2147483647 - --- | A maximum depth for nested computations. Currently, this is set very high because deep recursion is common in type inference over the Hydra kernel. -maxTraceDepth :: Int -maxTraceDepth = 5000 - --- | A standard warning message for auto-generated files -warningAutoGeneratedFile :: String -warningAutoGeneratedFile = "Note: this is an automatically generated file. Do not edit." diff --git a/src/gen-main/haskell/Hydra/Context.hs b/src/gen-main/haskell/Hydra/Context.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Context.hs +++ /dev/null @@ -1,47 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Execution context for tracing and diagnostics - -module Hydra.Context where - -import qualified Hydra.Core as Core -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | An execution context for tracing and diagnostics, threaded through function calls -data Context = - Context { - -- | A stack of context labels describing the current execution path - contextTrace :: [String], - -- | A log of warnings and/or info messages - contextMessages :: [String], - -- | A map of string keys to arbitrary terms as values, for application-specific use - contextOther :: (M.Map Core.Name Core.Term)} - deriving (Eq, Ord, Read, Show) - -_Context = Core.Name "hydra.context.Context" - -_Context_trace = Core.Name "trace" - -_Context_messages = Core.Name "messages" - -_Context_other = Core.Name "other" - --- | A particular domain object (such as an error) together with an execution context -data InContext e = - InContext { - -- | A domain object; typically an error - inContextObject :: e, - -- | The execution context at the point of capture - inContextContext :: Context} - deriving (Eq, Ord, Read, Show) - -_InContext = Core.Name "hydra.context.InContext" - -_InContext_object = Core.Name "object" - -_InContext_context = Core.Name "context" diff --git a/src/gen-main/haskell/Hydra/Core.hs b/src/gen-main/haskell/Hydra/Core.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Core.hs +++ /dev/null @@ -1,737 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Hydra's core data model, consisting of the fundamental hydra.core.Term type and all of its dependencies. - -module Hydra.Core where - -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | A term together with an annotation -data AnnotatedTerm = - AnnotatedTerm { - -- | The term being annotated - annotatedTermBody :: Term, - -- | The annotation as a map from keys to values - annotatedTermAnnotation :: (M.Map Name Term)} - deriving (Eq, Ord, Read, Show) - -_AnnotatedTerm = Name "hydra.core.AnnotatedTerm" - -_AnnotatedTerm_body = Name "body" - -_AnnotatedTerm_annotation = Name "annotation" - --- | A type together with an annotation -data AnnotatedType = - AnnotatedType { - -- | The type being annotated - annotatedTypeBody :: Type, - -- | The annotation as a map from keys to values - annotatedTypeAnnotation :: (M.Map Name Term)} - deriving (Eq, Ord, Read, Show) - -_AnnotatedType = Name "hydra.core.AnnotatedType" - -_AnnotatedType_body = Name "body" - -_AnnotatedType_annotation = Name "annotation" - --- | A term which applies a function to an argument -data Application = - Application { - -- | The left-hand side of the application - applicationFunction :: Term, - -- | The right-hand side of the application - applicationArgument :: Term} - deriving (Eq, Ord, Read, Show) - -_Application = Name "hydra.core.Application" - -_Application_function = Name "function" - -_Application_argument = Name "argument" - --- | The type-level analog of an application term -data ApplicationType = - ApplicationType { - -- | The left-hand side of the application - applicationTypeFunction :: Type, - -- | The right-hand side of the application - applicationTypeArgument :: Type} - deriving (Eq, Ord, Read, Show) - -_ApplicationType = Name "hydra.core.ApplicationType" - -_ApplicationType_function = Name "function" - -_ApplicationType_argument = Name "argument" - --- | A field with an optional type scheme, used to bind variables to terms in a 'let' expression -data Binding = - Binding { - -- | The name of the bound variable - bindingName :: Name, - -- | The term to which the variable is bound - bindingTerm :: Term, - -- | The optional type of the bound term - bindingType :: (Maybe TypeScheme)} - deriving (Eq, Ord, Read, Show) - -_Binding = Name "hydra.core.Binding" - -_Binding_name = Name "name" - -_Binding_term = Name "term" - -_Binding_type = Name "type" - --- | A union elimination; a case statement -data CaseStatement = - CaseStatement { - -- | The name of the union type - caseStatementTypeName :: Name, - -- | An optional default case, used if none of the explicit cases match - caseStatementDefault :: (Maybe Term), - -- | A list of case alternatives, one per union field - caseStatementCases :: [Field]} - deriving (Eq, Ord, Read, Show) - -_CaseStatement = Name "hydra.core.CaseStatement" - -_CaseStatement_typeName = Name "typeName" - -_CaseStatement_default = Name "default" - -_CaseStatement_cases = Name "cases" - --- | A type which provides a choice between a 'left' type and a 'right' type -data EitherType = - EitherType { - -- | The 'left' alternative - eitherTypeLeft :: Type, - -- | The 'right' alternative - eitherTypeRight :: Type} - deriving (Eq, Ord, Read, Show) - -_EitherType = Name "hydra.core.EitherType" - -_EitherType_left = Name "left" - -_EitherType_right = Name "right" - --- | A type which pairs a 'first' type and a 'second' type -data PairType = - PairType { - -- | The first component of the pair - pairTypeFirst :: Type, - -- | The second component of the pair - pairTypeSecond :: Type} - deriving (Eq, Ord, Read, Show) - -_PairType = Name "hydra.core.PairType" - -_PairType_first = Name "first" - -_PairType_second = Name "second" - --- | A corresponding elimination for an introduction term -data Elimination = - -- | Eliminates a record by projecting a given field - EliminationRecord Projection | - -- | Eliminates a union term by matching over the fields of the union. This is a case statement. - EliminationUnion CaseStatement | - -- | Unwrap a wrapped term - EliminationWrap Name - deriving (Eq, Ord, Read, Show) - -_Elimination = Name "hydra.core.Elimination" - -_Elimination_record = Name "record" - -_Elimination_union = Name "union" - -_Elimination_wrap = Name "wrap" - --- | A name/term pair -data Field = - Field { - -- | The name of the field - fieldName :: Name, - -- | The term value of the field - fieldTerm :: Term} - deriving (Eq, Ord, Read, Show) - -_Field = Name "hydra.core.Field" - -_Field_name = Name "name" - -_Field_term = Name "term" - --- | A name/type pair -data FieldType = - FieldType { - -- | The name of the field - fieldTypeName :: Name, - -- | The type of the field - fieldTypeType :: Type} - deriving (Eq, Ord, Read, Show) - -_FieldType = Name "hydra.core.FieldType" - -_FieldType_name = Name "name" - -_FieldType_type = Name "type" - --- | A floating-point type -data FloatType = - -- | An arbitrary-precision floating-point type - FloatTypeBigfloat | - -- | A 32-bit floating-point type - FloatTypeFloat32 | - -- | A 64-bit floating-point type - FloatTypeFloat64 - deriving (Eq, Ord, Read, Show) - -_FloatType = Name "hydra.core.FloatType" - -_FloatType_bigfloat = Name "bigfloat" - -_FloatType_float32 = Name "float32" - -_FloatType_float64 = Name "float64" - --- | A floating-point literal value -data FloatValue = - -- | An arbitrary-precision floating-point value - FloatValueBigfloat Double | - -- | A 32-bit floating-point value - FloatValueFloat32 Float | - -- | A 64-bit floating-point value - FloatValueFloat64 Double - deriving (Eq, Ord, Read, Show) - -_FloatValue = Name "hydra.core.FloatValue" - -_FloatValue_bigfloat = Name "bigfloat" - -_FloatValue_float32 = Name "float32" - -_FloatValue_float64 = Name "float64" - --- | A universally quantified type; the System F equivalent of a type scheme, and the type-level equivalent of a lambda term. -data ForallType = - ForallType { - -- | The variable which is bound by the lambda - forallTypeParameter :: Name, - -- | The body of the lambda - forallTypeBody :: Type} - deriving (Eq, Ord, Read, Show) - -_ForallType = Name "hydra.core.ForallType" - -_ForallType_parameter = Name "parameter" - -_ForallType_body = Name "body" - --- | A function -data Function = - -- | An elimination for any of a few term variants - FunctionElimination Elimination | - -- | A function abstraction (lambda) - FunctionLambda Lambda | - -- | A reference to a built-in (primitive) function - FunctionPrimitive Name - deriving (Eq, Ord, Read, Show) - -_Function = Name "hydra.core.Function" - -_Function_elimination = Name "elimination" - -_Function_lambda = Name "lambda" - -_Function_primitive = Name "primitive" - --- | A function type, also known as an arrow type -data FunctionType = - FunctionType { - -- | The domain (input) type of the function - functionTypeDomain :: Type, - -- | The codomain (output) type of the function - functionTypeCodomain :: Type} - deriving (Eq, Ord, Read, Show) - -_FunctionType = Name "hydra.core.FunctionType" - -_FunctionType_domain = Name "domain" - -_FunctionType_codomain = Name "codomain" - --- | An instance of a union type; i.e. a string-indexed generalization of inl() or inr() -data Injection = - Injection { - -- | The name of the union type - injectionTypeName :: Name, - -- | The field being injected, including its name and value - injectionField :: Field} - deriving (Eq, Ord, Read, Show) - -_Injection = Name "hydra.core.Injection" - -_Injection_typeName = Name "typeName" - -_Injection_field = Name "field" - --- | An integer type -data IntegerType = - -- | An arbitrary-precision integer type - IntegerTypeBigint | - -- | An 8-bit signed integer type - IntegerTypeInt8 | - -- | A 16-bit signed integer type - IntegerTypeInt16 | - -- | A 32-bit signed integer type - IntegerTypeInt32 | - -- | A 64-bit signed integer type - IntegerTypeInt64 | - -- | An 8-bit unsigned integer type - IntegerTypeUint8 | - -- | A 16-bit unsigned integer type - IntegerTypeUint16 | - -- | A 32-bit unsigned integer type - IntegerTypeUint32 | - -- | A 64-bit unsigned integer type - IntegerTypeUint64 - deriving (Eq, Ord, Read, Show) - -_IntegerType = Name "hydra.core.IntegerType" - -_IntegerType_bigint = Name "bigint" - -_IntegerType_int8 = Name "int8" - -_IntegerType_int16 = Name "int16" - -_IntegerType_int32 = Name "int32" - -_IntegerType_int64 = Name "int64" - -_IntegerType_uint8 = Name "uint8" - -_IntegerType_uint16 = Name "uint16" - -_IntegerType_uint32 = Name "uint32" - -_IntegerType_uint64 = Name "uint64" - --- | An integer literal value -data IntegerValue = - -- | An arbitrary-precision integer value - IntegerValueBigint Integer | - -- | An 8-bit signed integer value - IntegerValueInt8 I.Int8 | - -- | A 16-bit signed integer value (short value) - IntegerValueInt16 I.Int16 | - -- | A 32-bit signed integer value (int value) - IntegerValueInt32 Int | - -- | A 64-bit signed integer value (long value) - IntegerValueInt64 I.Int64 | - -- | An 8-bit unsigned integer value (byte) - IntegerValueUint8 I.Int16 | - -- | A 16-bit unsigned integer value - IntegerValueUint16 Int | - -- | A 32-bit unsigned integer value (unsigned int) - IntegerValueUint32 I.Int64 | - -- | A 64-bit unsigned integer value (unsigned long) - IntegerValueUint64 Integer - deriving (Eq, Ord, Read, Show) - -_IntegerValue = Name "hydra.core.IntegerValue" - -_IntegerValue_bigint = Name "bigint" - -_IntegerValue_int8 = Name "int8" - -_IntegerValue_int16 = Name "int16" - -_IntegerValue_int32 = Name "int32" - -_IntegerValue_int64 = Name "int64" - -_IntegerValue_uint8 = Name "uint8" - -_IntegerValue_uint16 = Name "uint16" - -_IntegerValue_uint32 = Name "uint32" - -_IntegerValue_uint64 = Name "uint64" - --- | A function abstraction (lambda) -data Lambda = - Lambda { - -- | The parameter of the lambda - lambdaParameter :: Name, - -- | An optional domain type for the lambda - lambdaDomain :: (Maybe Type), - -- | The body of the lambda - lambdaBody :: Term} - deriving (Eq, Ord, Read, Show) - -_Lambda = Name "hydra.core.Lambda" - -_Lambda_parameter = Name "parameter" - -_Lambda_domain = Name "domain" - -_Lambda_body = Name "body" - --- | A set of (possibly recursive) 'let' bindings together with a body in which they are bound -data Let = - Let { - -- | The list of variable bindings - letBindings :: [Binding], - -- | The body term in which the variables are bound - letBody :: Term} - deriving (Eq, Ord, Read, Show) - -_Let = Name "hydra.core.Let" - -_Let_bindings = Name "bindings" - -_Let_body = Name "body" - --- | A term constant; an instance of a literal type -data Literal = - -- | A binary literal - LiteralBinary B.ByteString | - -- | A boolean literal - LiteralBoolean Bool | - -- | A floating-point literal - LiteralFloat FloatValue | - -- | An integer literal - LiteralInteger IntegerValue | - -- | A string literal - LiteralString String - deriving (Eq, Ord, Read, Show) - -_Literal = Name "hydra.core.Literal" - -_Literal_binary = Name "binary" - -_Literal_boolean = Name "boolean" - -_Literal_float = Name "float" - -_Literal_integer = Name "integer" - -_Literal_string = Name "string" - --- | Any of a fixed set of literal types, also called atomic types, base types, primitive types, or type constants -data LiteralType = - -- | The type of a binary (byte string) value - LiteralTypeBinary | - -- | The type of a boolean (true/false) value - LiteralTypeBoolean | - -- | The type of a floating-point value - LiteralTypeFloat FloatType | - -- | The type of an integer value - LiteralTypeInteger IntegerType | - -- | The type of a string value - LiteralTypeString - deriving (Eq, Ord, Read, Show) - -_LiteralType = Name "hydra.core.LiteralType" - -_LiteralType_binary = Name "binary" - -_LiteralType_boolean = Name "boolean" - -_LiteralType_float = Name "float" - -_LiteralType_integer = Name "integer" - -_LiteralType_string = Name "string" - --- | A map type -data MapType = - MapType { - -- | The type of keys in the map - mapTypeKeys :: Type, - -- | The type of values in the map - mapTypeValues :: Type} - deriving (Eq, Ord, Read, Show) - -_MapType = Name "hydra.core.MapType" - -_MapType_keys = Name "keys" - -_MapType_values = Name "values" - --- | A unique identifier in some context; a string-valued key -newtype Name = - Name { - unName :: String} - deriving (Eq, Ord, Read, Show) - -_Name = Name "hydra.core.Name" - --- | A record elimination; a projection -data Projection = - Projection { - -- | The name of the record type - projectionTypeName :: Name, - -- | The name of the projected field - projectionField :: Name} - deriving (Eq, Ord, Read, Show) - -_Projection = Name "hydra.core.Projection" - -_Projection_typeName = Name "typeName" - -_Projection_field = Name "field" - --- | A record, or labeled tuple; a map of field names to terms -data Record = - Record { - -- | The name of the record type - recordTypeName :: Name, - -- | The fields of the record, as a list of name/term pairs - recordFields :: [Field]} - deriving (Eq, Ord, Read, Show) - -_Record = Name "hydra.core.Record" - -_Record_typeName = Name "typeName" - -_Record_fields = Name "fields" - --- | A data term -data Term = - -- | A term annotated with metadata - TermAnnotated AnnotatedTerm | - -- | A function application - TermApplication Application | - -- | An either value - TermEither (Either Term Term) | - -- | A function term - TermFunction Function | - -- | A 'let' term, which binds variables to terms - TermLet Let | - -- | A list - TermList [Term] | - -- | A literal value - TermLiteral Literal | - -- | A map of keys to values - TermMap (M.Map Term Term) | - -- | An optional value - TermMaybe (Maybe Term) | - -- | A pair (2-tuple) - TermPair (Term, Term) | - -- | A record term - TermRecord Record | - -- | A set of values - TermSet (S.Set Term) | - -- | A System F type application term - TermTypeApplication TypeApplicationTerm | - -- | A System F type abstraction term - TermTypeLambda TypeLambda | - -- | An injection; an instance of a union type - TermUnion Injection | - -- | A unit value; a term with no value - TermUnit | - -- | A variable reference - TermVariable Name | - -- | A wrapped term; an instance of a wrapper type (newtype) - TermWrap WrappedTerm - deriving (Eq, Ord, Read, Show) - -_Term = Name "hydra.core.Term" - -_Term_annotated = Name "annotated" - -_Term_application = Name "application" - -_Term_either = Name "either" - -_Term_function = Name "function" - -_Term_let = Name "let" - -_Term_list = Name "list" - -_Term_literal = Name "literal" - -_Term_map = Name "map" - -_Term_maybe = Name "maybe" - -_Term_pair = Name "pair" - -_Term_record = Name "record" - -_Term_set = Name "set" - -_Term_typeApplication = Name "typeApplication" - -_Term_typeLambda = Name "typeLambda" - -_Term_union = Name "union" - -_Term_unit = Name "unit" - -_Term_variable = Name "variable" - -_Term_wrap = Name "wrap" - --- | A data type -data Type = - -- | An annotated type - TypeAnnotated AnnotatedType | - -- | A type application - TypeApplication ApplicationType | - -- | An either (sum) type - TypeEither EitherType | - -- | A universally quantified (polymorphic) type - TypeForall ForallType | - -- | A function type - TypeFunction FunctionType | - -- | A list type - TypeList Type | - -- | A literal type - TypeLiteral LiteralType | - -- | A map type - TypeMap MapType | - -- | An optional type - TypeMaybe Type | - -- | A pair (2-tuple) type - TypePair PairType | - -- | A record type - TypeRecord [FieldType] | - -- | A set type - TypeSet Type | - -- | A union type with field names - TypeUnion [FieldType] | - -- | The unit type - TypeUnit | - -- | A type variable - TypeVariable Name | - -- | The void (uninhabited, or bottom) type - TypeVoid | - -- | A wrapped type (newtype) - TypeWrap Type - deriving (Eq, Ord, Read, Show) - -_Type = Name "hydra.core.Type" - -_Type_annotated = Name "annotated" - -_Type_application = Name "application" - -_Type_either = Name "either" - -_Type_forall = Name "forall" - -_Type_function = Name "function" - -_Type_list = Name "list" - -_Type_literal = Name "literal" - -_Type_map = Name "map" - -_Type_maybe = Name "maybe" - -_Type_pair = Name "pair" - -_Type_record = Name "record" - -_Type_set = Name "set" - -_Type_union = Name "union" - -_Type_unit = Name "unit" - -_Type_variable = Name "variable" - -_Type_void = Name "void" - -_Type_wrap = Name "wrap" - --- | A term applied to a type; a type application -data TypeApplicationTerm = - TypeApplicationTerm { - -- | The term being applied to a type - typeApplicationTermBody :: Term, - -- | The type argument - typeApplicationTermType :: Type} - deriving (Eq, Ord, Read, Show) - -_TypeApplicationTerm = Name "hydra.core.TypeApplicationTerm" - -_TypeApplicationTerm_body = Name "body" - -_TypeApplicationTerm_type = Name "type" - --- | A System F type abstraction term -data TypeLambda = - TypeLambda { - -- | The type variable introduced by the abstraction - typeLambdaParameter :: Name, - -- | The body of the abstraction - typeLambdaBody :: Term} - deriving (Eq, Ord, Read, Show) - -_TypeLambda = Name "hydra.core.TypeLambda" - -_TypeLambda_parameter = Name "parameter" - -_TypeLambda_body = Name "body" - --- | A type expression together with free type variables occurring in the expression -data TypeScheme = - TypeScheme { - -- | The free type variables - typeSchemeVariables :: [Name], - -- | The type expression - typeSchemeType :: Type, - -- | Optional metadata for type variables, including typeclass constraints. The map keys are type variable names. - typeSchemeConstraints :: (Maybe (M.Map Name TypeVariableMetadata))} - deriving (Eq, Ord, Read, Show) - -_TypeScheme = Name "hydra.core.TypeScheme" - -_TypeScheme_variables = Name "variables" - -_TypeScheme_type = Name "type" - -_TypeScheme_constraints = Name "constraints" - --- | Metadata associated with a type variable, including typeclass constraints -data TypeVariableMetadata = - TypeVariableMetadata { - -- | The set of typeclass constraints on this type variable - typeVariableMetadataClasses :: (S.Set Name)} - deriving (Eq, Ord, Read, Show) - -_TypeVariableMetadata = Name "hydra.core.TypeVariableMetadata" - -_TypeVariableMetadata_classes = Name "classes" - --- | A term wrapped in a type name -data WrappedTerm = - WrappedTerm { - -- | The name of the wrapper type - wrappedTermTypeName :: Name, - -- | The wrapped term - wrappedTermBody :: Term} - deriving (Eq, Ord, Read, Show) - -_WrappedTerm = Name "hydra.core.WrappedTerm" - -_WrappedTerm_typeName = Name "typeName" - -_WrappedTerm_body = Name "body" diff --git a/src/gen-main/haskell/Hydra/Decode/Ast.hs b/src/gen-main/haskell/Hydra/Decode/Ast.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Decode/Ast.hs +++ /dev/null @@ -1,229 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Term decoders for hydra.ast - -module Hydra.Decode.Ast where - -import qualified Hydra.Ast as Ast -import qualified Hydra.Core as Core -import qualified Hydra.Errors as Errors -import qualified Hydra.Extract.Helpers as Helpers -import qualified Hydra.Graph as Graph -import qualified Hydra.Lexical as Lexical -import qualified Hydra.Lib.Eithers as Eithers -import qualified Hydra.Lib.Maps as Maps -import qualified Hydra.Lib.Maybes as Maybes -import qualified Hydra.Lib.Strings as Strings -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -associativity :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Ast.Associativity -associativity cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermUnion v0 -> - let field = Core.injectionField v0 - fname = Core.fieldName field - fterm = Core.fieldTerm field - variantMap = - Maps.fromList [ - (Core.Name "none", (\input -> Eithers.map (\t -> Ast.AssociativityNone) (Helpers.decodeUnit cx input))), - (Core.Name "left", (\input -> Eithers.map (\t -> Ast.AssociativityLeft) (Helpers.decodeUnit cx input))), - (Core.Name "right", (\input -> Eithers.map (\t -> Ast.AssociativityRight) (Helpers.decodeUnit cx input))), - (Core.Name "both", (\input -> Eithers.map (\t -> Ast.AssociativityBoth) (Helpers.decodeUnit cx input)))] - in (Maybes.maybe (Left (Errors.DecodingError (Strings.cat [ - "no such field ", - (Core.unName fname), - " in union"]))) (\f -> f fterm) (Maps.lookup fname variantMap)) - _ -> Left (Errors.DecodingError "expected union")) (Lexical.stripAndDereferenceTermEither cx raw) - -blockStyle :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Ast.BlockStyle -blockStyle cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "indent" (Helpers.decodeMaybe (\cx -> \raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw))) fieldMap cx) (\field_indent -> Eithers.bind (Helpers.requireField "newlineBeforeContent" (\cx -> \raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralBoolean v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected boolean literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw)) fieldMap cx) (\field_newlineBeforeContent -> Eithers.bind (Helpers.requireField "newlineAfterContent" (\cx -> \raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralBoolean v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected boolean literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw)) fieldMap cx) (\field_newlineAfterContent -> Right (Ast.BlockStyle { - Ast.blockStyleIndent = field_indent, - Ast.blockStyleNewlineBeforeContent = field_newlineBeforeContent, - Ast.blockStyleNewlineAfterContent = field_newlineAfterContent}))))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -bracketExpr :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Ast.BracketExpr -bracketExpr cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "brackets" brackets fieldMap cx) (\field_brackets -> Eithers.bind (Helpers.requireField "enclosed" expr fieldMap cx) (\field_enclosed -> Eithers.bind (Helpers.requireField "style" blockStyle fieldMap cx) (\field_style -> Right (Ast.BracketExpr { - Ast.bracketExprBrackets = field_brackets, - Ast.bracketExprEnclosed = field_enclosed, - Ast.bracketExprStyle = field_style}))))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -brackets :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Ast.Brackets -brackets cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "open" symbol fieldMap cx) (\field_open -> Eithers.bind (Helpers.requireField "close" symbol fieldMap cx) (\field_close -> Right (Ast.Brackets { - Ast.bracketsOpen = field_open, - Ast.bracketsClose = field_close})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -expr :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Ast.Expr -expr cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermUnion v0 -> - let field = Core.injectionField v0 - fname = Core.fieldName field - fterm = Core.fieldTerm field - variantMap = - Maps.fromList [ - (Core.Name "const", (\input -> Eithers.map (\t -> Ast.ExprConst t) (symbol cx input))), - (Core.Name "indent", (\input -> Eithers.map (\t -> Ast.ExprIndent t) (indentedExpression cx input))), - (Core.Name "op", (\input -> Eithers.map (\t -> Ast.ExprOp t) (opExpr cx input))), - (Core.Name "brackets", (\input -> Eithers.map (\t -> Ast.ExprBrackets t) (bracketExpr cx input))), - (Core.Name "seq", (\input -> Eithers.map (\t -> Ast.ExprSeq t) (seqExpr cx input)))] - in (Maybes.maybe (Left (Errors.DecodingError (Strings.cat [ - "no such field ", - (Core.unName fname), - " in union"]))) (\f -> f fterm) (Maps.lookup fname variantMap)) - _ -> Left (Errors.DecodingError "expected union")) (Lexical.stripAndDereferenceTermEither cx raw) - -indentStyle :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Ast.IndentStyle -indentStyle cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermUnion v0 -> - let field = Core.injectionField v0 - fname = Core.fieldName field - fterm = Core.fieldTerm field - variantMap = - Maps.fromList [ - (Core.Name "allLines", (\input -> Eithers.map (\t -> Ast.IndentStyleAllLines t) (Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx input)))), - (Core.Name "subsequentLines", (\input -> Eithers.map (\t -> Ast.IndentStyleSubsequentLines t) (Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx input))))] - in (Maybes.maybe (Left (Errors.DecodingError (Strings.cat [ - "no such field ", - (Core.unName fname), - " in union"]))) (\f -> f fterm) (Maps.lookup fname variantMap)) - _ -> Left (Errors.DecodingError "expected union")) (Lexical.stripAndDereferenceTermEither cx raw) - -indentedExpression :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Ast.IndentedExpression -indentedExpression cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "style" indentStyle fieldMap cx) (\field_style -> Eithers.bind (Helpers.requireField "expr" expr fieldMap cx) (\field_expr -> Right (Ast.IndentedExpression { - Ast.indentedExpressionStyle = field_style, - Ast.indentedExpressionExpr = field_expr})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -op :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Ast.Op -op cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "symbol" symbol fieldMap cx) (\field_symbol -> Eithers.bind (Helpers.requireField "padding" padding fieldMap cx) (\field_padding -> Eithers.bind (Helpers.requireField "precedence" precedence fieldMap cx) (\field_precedence -> Eithers.bind (Helpers.requireField "associativity" associativity fieldMap cx) (\field_associativity -> Right (Ast.Op { - Ast.opSymbol = field_symbol, - Ast.opPadding = field_padding, - Ast.opPrecedence = field_precedence, - Ast.opAssociativity = field_associativity})))))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -opExpr :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Ast.OpExpr -opExpr cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "op" op fieldMap cx) (\field_op -> Eithers.bind (Helpers.requireField "lhs" expr fieldMap cx) (\field_lhs -> Eithers.bind (Helpers.requireField "rhs" expr fieldMap cx) (\field_rhs -> Right (Ast.OpExpr { - Ast.opExprOp = field_op, - Ast.opExprLhs = field_lhs, - Ast.opExprRhs = field_rhs}))))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -padding :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Ast.Padding -padding cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "left" ws fieldMap cx) (\field_left -> Eithers.bind (Helpers.requireField "right" ws fieldMap cx) (\field_right -> Right (Ast.Padding { - Ast.paddingLeft = field_left, - Ast.paddingRight = field_right})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -precedence :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Ast.Precedence -precedence cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermWrap v0 -> Eithers.map (\b -> Ast.Precedence b) ((\raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralInteger v2 -> case v2 of - Core.IntegerValueInt32 v3 -> Right v3 - _ -> Left (Errors.DecodingError "expected int32 value") - _ -> Left (Errors.DecodingError "expected int32 literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw)) (Core.wrappedTermBody v0)) - _ -> Left (Errors.DecodingError "expected wrapped type")) (Lexical.stripAndDereferenceTermEither cx raw) - -seqExpr :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Ast.SeqExpr -seqExpr cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "op" op fieldMap cx) (\field_op -> Eithers.bind (Helpers.requireField "elements" (Helpers.decodeList expr) fieldMap cx) (\field_elements -> Right (Ast.SeqExpr { - Ast.seqExprOp = field_op, - Ast.seqExprElements = field_elements})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -symbol :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Ast.Symbol -symbol cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermWrap v0 -> Eithers.map (\b -> Ast.Symbol b) ((\raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw)) (Core.wrappedTermBody v0)) - _ -> Left (Errors.DecodingError "expected wrapped type")) (Lexical.stripAndDereferenceTermEither cx raw) - -ws :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Ast.Ws -ws cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermUnion v0 -> - let field = Core.injectionField v0 - fname = Core.fieldName field - fterm = Core.fieldTerm field - variantMap = - Maps.fromList [ - (Core.Name "none", (\input -> Eithers.map (\t -> Ast.WsNone) (Helpers.decodeUnit cx input))), - (Core.Name "space", (\input -> Eithers.map (\t -> Ast.WsSpace) (Helpers.decodeUnit cx input))), - (Core.Name "break", (\input -> Eithers.map (\t -> Ast.WsBreak) (Helpers.decodeUnit cx input))), - (Core.Name "breakAndIndent", (\input -> Eithers.map (\t -> Ast.WsBreakAndIndent t) (Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx input)))), - (Core.Name "doubleBreak", (\input -> Eithers.map (\t -> Ast.WsDoubleBreak) (Helpers.decodeUnit cx input)))] - in (Maybes.maybe (Left (Errors.DecodingError (Strings.cat [ - "no such field ", - (Core.unName fname), - " in union"]))) (\f -> f fterm) (Maps.lookup fname variantMap)) - _ -> Left (Errors.DecodingError "expected union")) (Lexical.stripAndDereferenceTermEither cx raw) diff --git a/src/gen-main/haskell/Hydra/Decode/Classes.hs b/src/gen-main/haskell/Hydra/Decode/Classes.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Decode/Classes.hs +++ /dev/null @@ -1,39 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Term decoders for hydra.classes - -module Hydra.Decode.Classes where - -import qualified Hydra.Classes as Classes -import qualified Hydra.Core as Core -import qualified Hydra.Errors as Errors -import qualified Hydra.Extract.Helpers as Helpers -import qualified Hydra.Graph as Graph -import qualified Hydra.Lexical as Lexical -import qualified Hydra.Lib.Eithers as Eithers -import qualified Hydra.Lib.Maps as Maps -import qualified Hydra.Lib.Maybes as Maybes -import qualified Hydra.Lib.Strings as Strings -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -typeClass :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Classes.TypeClass -typeClass cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermUnion v0 -> - let field = Core.injectionField v0 - fname = Core.fieldName field - fterm = Core.fieldTerm field - variantMap = - Maps.fromList [ - (Core.Name "equality", (\input -> Eithers.map (\t -> Classes.TypeClassEquality) (Helpers.decodeUnit cx input))), - (Core.Name "ordering", (\input -> Eithers.map (\t -> Classes.TypeClassOrdering) (Helpers.decodeUnit cx input)))] - in (Maybes.maybe (Left (Errors.DecodingError (Strings.cat [ - "no such field ", - (Core.unName fname), - " in union"]))) (\f -> f fterm) (Maps.lookup fname variantMap)) - _ -> Left (Errors.DecodingError "expected union")) (Lexical.stripAndDereferenceTermEither cx raw) diff --git a/src/gen-main/haskell/Hydra/Decode/Coders.hs b/src/gen-main/haskell/Hydra/Decode/Coders.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Decode/Coders.hs +++ /dev/null @@ -1,66 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Term decoders for hydra.coders - -module Hydra.Decode.Coders where - -import qualified Hydra.Coders as Coders -import qualified Hydra.Core as Core -import qualified Hydra.Errors as Errors -import qualified Hydra.Extract.Helpers as Helpers -import qualified Hydra.Graph as Graph -import qualified Hydra.Lexical as Lexical -import qualified Hydra.Lib.Eithers as Eithers -import qualified Hydra.Lib.Maps as Maps -import qualified Hydra.Lib.Maybes as Maybes -import qualified Hydra.Lib.Strings as Strings -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -coderDirection :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Coders.CoderDirection -coderDirection cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermUnion v0 -> - let field = Core.injectionField v0 - fname = Core.fieldName field - fterm = Core.fieldTerm field - variantMap = - Maps.fromList [ - (Core.Name "encode", (\input -> Eithers.map (\t -> Coders.CoderDirectionEncode) (Helpers.decodeUnit cx input))), - (Core.Name "decode", (\input -> Eithers.map (\t -> Coders.CoderDirectionDecode) (Helpers.decodeUnit cx input)))] - in (Maybes.maybe (Left (Errors.DecodingError (Strings.cat [ - "no such field ", - (Core.unName fname), - " in union"]))) (\f -> f fterm) (Maps.lookup fname variantMap)) - _ -> Left (Errors.DecodingError "expected union")) (Lexical.stripAndDereferenceTermEither cx raw) - -languageName :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Coders.LanguageName -languageName cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermWrap v0 -> Eithers.map (\b -> Coders.LanguageName b) ((\raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw)) (Core.wrappedTermBody v0)) - _ -> Left (Errors.DecodingError "expected wrapped type")) (Lexical.stripAndDereferenceTermEither cx raw) - -traversalOrder :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Coders.TraversalOrder -traversalOrder cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermUnion v0 -> - let field = Core.injectionField v0 - fname = Core.fieldName field - fterm = Core.fieldTerm field - variantMap = - Maps.fromList [ - (Core.Name "pre", (\input -> Eithers.map (\t -> Coders.TraversalOrderPre) (Helpers.decodeUnit cx input))), - (Core.Name "post", (\input -> Eithers.map (\t -> Coders.TraversalOrderPost) (Helpers.decodeUnit cx input)))] - in (Maybes.maybe (Left (Errors.DecodingError (Strings.cat [ - "no such field ", - (Core.unName fname), - " in union"]))) (\f -> f fterm) (Maps.lookup fname variantMap)) - _ -> Left (Errors.DecodingError "expected union")) (Lexical.stripAndDereferenceTermEither cx raw) diff --git a/src/gen-main/haskell/Hydra/Decode/Context.hs b/src/gen-main/haskell/Hydra/Decode/Context.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Decode/Context.hs +++ /dev/null @@ -1,49 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Term decoders for hydra.context - -module Hydra.Decode.Context where - -import qualified Hydra.Context as Context -import qualified Hydra.Core as Core -import qualified Hydra.Decode.Core as Core_ -import qualified Hydra.Errors as Errors -import qualified Hydra.Extract.Helpers as Helpers -import qualified Hydra.Graph as Graph -import qualified Hydra.Lexical as Lexical -import qualified Hydra.Lib.Eithers as Eithers -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -context :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Context.Context -context cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "trace" (Helpers.decodeList (\cx -> \raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw))) fieldMap cx) (\field_trace -> Eithers.bind (Helpers.requireField "messages" (Helpers.decodeList (\cx -> \raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw))) fieldMap cx) (\field_messages -> Eithers.bind (Helpers.requireField "other" (Helpers.decodeMap Core_.name Core_.term) fieldMap cx) (\field_other -> Right (Context.Context { - Context.contextTrace = field_trace, - Context.contextMessages = field_messages, - Context.contextOther = field_other}))))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -inContext :: (Graph.Graph -> Core.Term -> Either Errors.DecodingError t0) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (Context.InContext t0) -inContext e cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "object" e fieldMap cx) (\field_object -> Eithers.bind (Helpers.requireField "context" context fieldMap cx) (\field_context -> Right (Context.InContext { - Context.inContextObject = field_object, - Context.inContextContext = field_context})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) diff --git a/src/gen-main/haskell/Hydra/Decode/Core.hs b/src/gen-main/haskell/Hydra/Decode/Core.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Decode/Core.hs +++ /dev/null @@ -1,573 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Term decoders for hydra.core - -module Hydra.Decode.Core where - -import qualified Hydra.Core as Core -import qualified Hydra.Errors as Errors -import qualified Hydra.Extract.Helpers as Helpers -import qualified Hydra.Graph as Graph -import qualified Hydra.Lexical as Lexical -import qualified Hydra.Lib.Eithers as Eithers -import qualified Hydra.Lib.Maps as Maps -import qualified Hydra.Lib.Maybes as Maybes -import qualified Hydra.Lib.Strings as Strings -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -annotatedTerm :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.AnnotatedTerm -annotatedTerm cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "body" term fieldMap cx) (\field_body -> Eithers.bind (Helpers.requireField "annotation" (Helpers.decodeMap name term) fieldMap cx) (\field_annotation -> Right (Core.AnnotatedTerm { - Core.annotatedTermBody = field_body, - Core.annotatedTermAnnotation = field_annotation})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -annotatedType :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.AnnotatedType -annotatedType cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "body" type_ fieldMap cx) (\field_body -> Eithers.bind (Helpers.requireField "annotation" (Helpers.decodeMap name term) fieldMap cx) (\field_annotation -> Right (Core.AnnotatedType { - Core.annotatedTypeBody = field_body, - Core.annotatedTypeAnnotation = field_annotation})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -application :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.Application -application cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "function" term fieldMap cx) (\field_function -> Eithers.bind (Helpers.requireField "argument" term fieldMap cx) (\field_argument -> Right (Core.Application { - Core.applicationFunction = field_function, - Core.applicationArgument = field_argument})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -applicationType :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.ApplicationType -applicationType cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "function" type_ fieldMap cx) (\field_function -> Eithers.bind (Helpers.requireField "argument" type_ fieldMap cx) (\field_argument -> Right (Core.ApplicationType { - Core.applicationTypeFunction = field_function, - Core.applicationTypeArgument = field_argument})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -binding :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.Binding -binding cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "name" name fieldMap cx) (\field_name -> Eithers.bind (Helpers.requireField "term" term fieldMap cx) (\field_term -> Eithers.bind (Helpers.requireField "type" (Helpers.decodeMaybe typeScheme) fieldMap cx) (\field_type -> Right (Core.Binding { - Core.bindingName = field_name, - Core.bindingTerm = field_term, - Core.bindingType = field_type}))))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -caseStatement :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.CaseStatement -caseStatement cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "typeName" name fieldMap cx) (\field_typeName -> Eithers.bind (Helpers.requireField "default" (Helpers.decodeMaybe term) fieldMap cx) (\field_default -> Eithers.bind (Helpers.requireField "cases" (Helpers.decodeList field) fieldMap cx) (\field_cases -> Right (Core.CaseStatement { - Core.caseStatementTypeName = field_typeName, - Core.caseStatementDefault = field_default, - Core.caseStatementCases = field_cases}))))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -eitherType :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.EitherType -eitherType cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "left" type_ fieldMap cx) (\field_left -> Eithers.bind (Helpers.requireField "right" type_ fieldMap cx) (\field_right -> Right (Core.EitherType { - Core.eitherTypeLeft = field_left, - Core.eitherTypeRight = field_right})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -elimination :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.Elimination -elimination cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermUnion v0 -> - let field = Core.injectionField v0 - fname = Core.fieldName field - fterm = Core.fieldTerm field - variantMap = - Maps.fromList [ - (Core.Name "record", (\input -> Eithers.map (\t -> Core.EliminationRecord t) (projection cx input))), - (Core.Name "union", (\input -> Eithers.map (\t -> Core.EliminationUnion t) (caseStatement cx input))), - (Core.Name "wrap", (\input -> Eithers.map (\t -> Core.EliminationWrap t) (name cx input)))] - in (Maybes.maybe (Left (Errors.DecodingError (Strings.cat [ - "no such field ", - (Core.unName fname), - " in union"]))) (\f -> f fterm) (Maps.lookup fname variantMap)) - _ -> Left (Errors.DecodingError "expected union")) (Lexical.stripAndDereferenceTermEither cx raw) - -field :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.Field -field cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "name" name fieldMap cx) (\field_name -> Eithers.bind (Helpers.requireField "term" term fieldMap cx) (\field_term -> Right (Core.Field { - Core.fieldName = field_name, - Core.fieldTerm = field_term})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -fieldType :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.FieldType -fieldType cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "name" name fieldMap cx) (\field_name -> Eithers.bind (Helpers.requireField "type" type_ fieldMap cx) (\field_type -> Right (Core.FieldType { - Core.fieldTypeName = field_name, - Core.fieldTypeType = field_type})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -floatType :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.FloatType -floatType cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermUnion v0 -> - let field = Core.injectionField v0 - fname = Core.fieldName field - fterm = Core.fieldTerm field - variantMap = - Maps.fromList [ - (Core.Name "bigfloat", (\input -> Eithers.map (\t -> Core.FloatTypeBigfloat) (Helpers.decodeUnit cx input))), - (Core.Name "float32", (\input -> Eithers.map (\t -> Core.FloatTypeFloat32) (Helpers.decodeUnit cx input))), - (Core.Name "float64", (\input -> Eithers.map (\t -> Core.FloatTypeFloat64) (Helpers.decodeUnit cx input)))] - in (Maybes.maybe (Left (Errors.DecodingError (Strings.cat [ - "no such field ", - (Core.unName fname), - " in union"]))) (\f -> f fterm) (Maps.lookup fname variantMap)) - _ -> Left (Errors.DecodingError "expected union")) (Lexical.stripAndDereferenceTermEither cx raw) - -floatValue :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.FloatValue -floatValue cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermUnion v0 -> - let field = Core.injectionField v0 - fname = Core.fieldName field - fterm = Core.fieldTerm field - variantMap = - Maps.fromList [ - (Core.Name "bigfloat", (\input -> Eithers.map (\t -> Core.FloatValueBigfloat t) (Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralFloat v2 -> case v2 of - Core.FloatValueBigfloat v3 -> Right v3 - _ -> Left (Errors.DecodingError "expected bigfloat value") - _ -> Left (Errors.DecodingError "expected bigfloat literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx input)))), - (Core.Name "float32", (\input -> Eithers.map (\t -> Core.FloatValueFloat32 t) (Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralFloat v2 -> case v2 of - Core.FloatValueFloat32 v3 -> Right v3 - _ -> Left (Errors.DecodingError "expected float32 value") - _ -> Left (Errors.DecodingError "expected float32 literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx input)))), - (Core.Name "float64", (\input -> Eithers.map (\t -> Core.FloatValueFloat64 t) (Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralFloat v2 -> case v2 of - Core.FloatValueFloat64 v3 -> Right v3 - _ -> Left (Errors.DecodingError "expected float64 value") - _ -> Left (Errors.DecodingError "expected float64 literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx input))))] - in (Maybes.maybe (Left (Errors.DecodingError (Strings.cat [ - "no such field ", - (Core.unName fname), - " in union"]))) (\f -> f fterm) (Maps.lookup fname variantMap)) - _ -> Left (Errors.DecodingError "expected union")) (Lexical.stripAndDereferenceTermEither cx raw) - -forallType :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.ForallType -forallType cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "parameter" name fieldMap cx) (\field_parameter -> Eithers.bind (Helpers.requireField "body" type_ fieldMap cx) (\field_body -> Right (Core.ForallType { - Core.forallTypeParameter = field_parameter, - Core.forallTypeBody = field_body})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -function :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.Function -function cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermUnion v0 -> - let field = Core.injectionField v0 - fname = Core.fieldName field - fterm = Core.fieldTerm field - variantMap = - Maps.fromList [ - (Core.Name "elimination", (\input -> Eithers.map (\t -> Core.FunctionElimination t) (elimination cx input))), - (Core.Name "lambda", (\input -> Eithers.map (\t -> Core.FunctionLambda t) (lambda cx input))), - (Core.Name "primitive", (\input -> Eithers.map (\t -> Core.FunctionPrimitive t) (name cx input)))] - in (Maybes.maybe (Left (Errors.DecodingError (Strings.cat [ - "no such field ", - (Core.unName fname), - " in union"]))) (\f -> f fterm) (Maps.lookup fname variantMap)) - _ -> Left (Errors.DecodingError "expected union")) (Lexical.stripAndDereferenceTermEither cx raw) - -functionType :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.FunctionType -functionType cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "domain" type_ fieldMap cx) (\field_domain -> Eithers.bind (Helpers.requireField "codomain" type_ fieldMap cx) (\field_codomain -> Right (Core.FunctionType { - Core.functionTypeDomain = field_domain, - Core.functionTypeCodomain = field_codomain})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -injection :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.Injection -injection cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "typeName" name fieldMap cx) (\field_typeName -> Eithers.bind (Helpers.requireField "field" field fieldMap cx) (\field_field -> Right (Core.Injection { - Core.injectionTypeName = field_typeName, - Core.injectionField = field_field})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -integerType :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.IntegerType -integerType cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermUnion v0 -> - let field = Core.injectionField v0 - fname = Core.fieldName field - fterm = Core.fieldTerm field - variantMap = - Maps.fromList [ - (Core.Name "bigint", (\input -> Eithers.map (\t -> Core.IntegerTypeBigint) (Helpers.decodeUnit cx input))), - (Core.Name "int8", (\input -> Eithers.map (\t -> Core.IntegerTypeInt8) (Helpers.decodeUnit cx input))), - (Core.Name "int16", (\input -> Eithers.map (\t -> Core.IntegerTypeInt16) (Helpers.decodeUnit cx input))), - (Core.Name "int32", (\input -> Eithers.map (\t -> Core.IntegerTypeInt32) (Helpers.decodeUnit cx input))), - (Core.Name "int64", (\input -> Eithers.map (\t -> Core.IntegerTypeInt64) (Helpers.decodeUnit cx input))), - (Core.Name "uint8", (\input -> Eithers.map (\t -> Core.IntegerTypeUint8) (Helpers.decodeUnit cx input))), - (Core.Name "uint16", (\input -> Eithers.map (\t -> Core.IntegerTypeUint16) (Helpers.decodeUnit cx input))), - (Core.Name "uint32", (\input -> Eithers.map (\t -> Core.IntegerTypeUint32) (Helpers.decodeUnit cx input))), - (Core.Name "uint64", (\input -> Eithers.map (\t -> Core.IntegerTypeUint64) (Helpers.decodeUnit cx input)))] - in (Maybes.maybe (Left (Errors.DecodingError (Strings.cat [ - "no such field ", - (Core.unName fname), - " in union"]))) (\f -> f fterm) (Maps.lookup fname variantMap)) - _ -> Left (Errors.DecodingError "expected union")) (Lexical.stripAndDereferenceTermEither cx raw) - -integerValue :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.IntegerValue -integerValue cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermUnion v0 -> - let field = Core.injectionField v0 - fname = Core.fieldName field - fterm = Core.fieldTerm field - variantMap = - Maps.fromList [ - (Core.Name "bigint", (\input -> Eithers.map (\t -> Core.IntegerValueBigint t) (Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralInteger v2 -> case v2 of - Core.IntegerValueBigint v3 -> Right v3 - _ -> Left (Errors.DecodingError "expected bigint value") - _ -> Left (Errors.DecodingError "expected bigint literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx input)))), - (Core.Name "int8", (\input -> Eithers.map (\t -> Core.IntegerValueInt8 t) (Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralInteger v2 -> case v2 of - Core.IntegerValueInt8 v3 -> Right v3 - _ -> Left (Errors.DecodingError "expected int8 value") - _ -> Left (Errors.DecodingError "expected int8 literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx input)))), - (Core.Name "int16", (\input -> Eithers.map (\t -> Core.IntegerValueInt16 t) (Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralInteger v2 -> case v2 of - Core.IntegerValueInt16 v3 -> Right v3 - _ -> Left (Errors.DecodingError "expected int16 value") - _ -> Left (Errors.DecodingError "expected int16 literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx input)))), - (Core.Name "int32", (\input -> Eithers.map (\t -> Core.IntegerValueInt32 t) (Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralInteger v2 -> case v2 of - Core.IntegerValueInt32 v3 -> Right v3 - _ -> Left (Errors.DecodingError "expected int32 value") - _ -> Left (Errors.DecodingError "expected int32 literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx input)))), - (Core.Name "int64", (\input -> Eithers.map (\t -> Core.IntegerValueInt64 t) (Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralInteger v2 -> case v2 of - Core.IntegerValueInt64 v3 -> Right v3 - _ -> Left (Errors.DecodingError "expected int64 value") - _ -> Left (Errors.DecodingError "expected int64 literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx input)))), - (Core.Name "uint8", (\input -> Eithers.map (\t -> Core.IntegerValueUint8 t) (Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralInteger v2 -> case v2 of - Core.IntegerValueUint8 v3 -> Right v3 - _ -> Left (Errors.DecodingError "expected uint8 value") - _ -> Left (Errors.DecodingError "expected uint8 literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx input)))), - (Core.Name "uint16", (\input -> Eithers.map (\t -> Core.IntegerValueUint16 t) (Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralInteger v2 -> case v2 of - Core.IntegerValueUint16 v3 -> Right v3 - _ -> Left (Errors.DecodingError "expected uint16 value") - _ -> Left (Errors.DecodingError "expected uint16 literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx input)))), - (Core.Name "uint32", (\input -> Eithers.map (\t -> Core.IntegerValueUint32 t) (Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralInteger v2 -> case v2 of - Core.IntegerValueUint32 v3 -> Right v3 - _ -> Left (Errors.DecodingError "expected uint32 value") - _ -> Left (Errors.DecodingError "expected uint32 literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx input)))), - (Core.Name "uint64", (\input -> Eithers.map (\t -> Core.IntegerValueUint64 t) (Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralInteger v2 -> case v2 of - Core.IntegerValueUint64 v3 -> Right v3 - _ -> Left (Errors.DecodingError "expected uint64 value") - _ -> Left (Errors.DecodingError "expected uint64 literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx input))))] - in (Maybes.maybe (Left (Errors.DecodingError (Strings.cat [ - "no such field ", - (Core.unName fname), - " in union"]))) (\f -> f fterm) (Maps.lookup fname variantMap)) - _ -> Left (Errors.DecodingError "expected union")) (Lexical.stripAndDereferenceTermEither cx raw) - -lambda :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.Lambda -lambda cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "parameter" name fieldMap cx) (\field_parameter -> Eithers.bind (Helpers.requireField "domain" (Helpers.decodeMaybe type_) fieldMap cx) (\field_domain -> Eithers.bind (Helpers.requireField "body" term fieldMap cx) (\field_body -> Right (Core.Lambda { - Core.lambdaParameter = field_parameter, - Core.lambdaDomain = field_domain, - Core.lambdaBody = field_body}))))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -let_ :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.Let -let_ cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "bindings" (Helpers.decodeList binding) fieldMap cx) (\field_bindings -> Eithers.bind (Helpers.requireField "body" term fieldMap cx) (\field_body -> Right (Core.Let { - Core.letBindings = field_bindings, - Core.letBody = field_body})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -literal :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.Literal -literal cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermUnion v0 -> - let field = Core.injectionField v0 - fname = Core.fieldName field - fterm = Core.fieldTerm field - variantMap = - Maps.fromList [ - (Core.Name "binary", (\input -> Eithers.map (\t -> Core.LiteralBinary t) (Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralBinary v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected binary literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx input)))), - (Core.Name "boolean", (\input -> Eithers.map (\t -> Core.LiteralBoolean t) (Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralBoolean v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected boolean literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx input)))), - (Core.Name "float", (\input -> Eithers.map (\t -> Core.LiteralFloat t) (floatValue cx input))), - (Core.Name "integer", (\input -> Eithers.map (\t -> Core.LiteralInteger t) (integerValue cx input))), - (Core.Name "string", (\input -> Eithers.map (\t -> Core.LiteralString t) (Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx input))))] - in (Maybes.maybe (Left (Errors.DecodingError (Strings.cat [ - "no such field ", - (Core.unName fname), - " in union"]))) (\f -> f fterm) (Maps.lookup fname variantMap)) - _ -> Left (Errors.DecodingError "expected union")) (Lexical.stripAndDereferenceTermEither cx raw) - -literalType :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.LiteralType -literalType cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermUnion v0 -> - let field = Core.injectionField v0 - fname = Core.fieldName field - fterm = Core.fieldTerm field - variantMap = - Maps.fromList [ - (Core.Name "binary", (\input -> Eithers.map (\t -> Core.LiteralTypeBinary) (Helpers.decodeUnit cx input))), - (Core.Name "boolean", (\input -> Eithers.map (\t -> Core.LiteralTypeBoolean) (Helpers.decodeUnit cx input))), - (Core.Name "float", (\input -> Eithers.map (\t -> Core.LiteralTypeFloat t) (floatType cx input))), - (Core.Name "integer", (\input -> Eithers.map (\t -> Core.LiteralTypeInteger t) (integerType cx input))), - (Core.Name "string", (\input -> Eithers.map (\t -> Core.LiteralTypeString) (Helpers.decodeUnit cx input)))] - in (Maybes.maybe (Left (Errors.DecodingError (Strings.cat [ - "no such field ", - (Core.unName fname), - " in union"]))) (\f -> f fterm) (Maps.lookup fname variantMap)) - _ -> Left (Errors.DecodingError "expected union")) (Lexical.stripAndDereferenceTermEither cx raw) - -mapType :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.MapType -mapType cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "keys" type_ fieldMap cx) (\field_keys -> Eithers.bind (Helpers.requireField "values" type_ fieldMap cx) (\field_values -> Right (Core.MapType { - Core.mapTypeKeys = field_keys, - Core.mapTypeValues = field_values})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -name :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.Name -name cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermWrap v0 -> Eithers.map (\b -> Core.Name b) ((\raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw)) (Core.wrappedTermBody v0)) - _ -> Left (Errors.DecodingError "expected wrapped type")) (Lexical.stripAndDereferenceTermEither cx raw) - -pairType :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.PairType -pairType cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "first" type_ fieldMap cx) (\field_first -> Eithers.bind (Helpers.requireField "second" type_ fieldMap cx) (\field_second -> Right (Core.PairType { - Core.pairTypeFirst = field_first, - Core.pairTypeSecond = field_second})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -projection :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.Projection -projection cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "typeName" name fieldMap cx) (\field_typeName -> Eithers.bind (Helpers.requireField "field" name fieldMap cx) (\field_field -> Right (Core.Projection { - Core.projectionTypeName = field_typeName, - Core.projectionField = field_field})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -record :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.Record -record cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "typeName" name fieldMap cx) (\field_typeName -> Eithers.bind (Helpers.requireField "fields" (Helpers.decodeList field) fieldMap cx) (\field_fields -> Right (Core.Record { - Core.recordTypeName = field_typeName, - Core.recordFields = field_fields})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -term :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.Term -term cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermUnion v0 -> - let field = Core.injectionField v0 - fname = Core.fieldName field - fterm = Core.fieldTerm field - variantMap = - Maps.fromList [ - (Core.Name "annotated", (\input -> Eithers.map (\t -> Core.TermAnnotated t) (annotatedTerm cx input))), - (Core.Name "application", (\input -> Eithers.map (\t -> Core.TermApplication t) (application cx input))), - (Core.Name "either", (\input -> Eithers.map (\t -> Core.TermEither t) (Helpers.decodeEither term term cx input))), - (Core.Name "function", (\input -> Eithers.map (\t -> Core.TermFunction t) (function cx input))), - (Core.Name "let", (\input -> Eithers.map (\t -> Core.TermLet t) (let_ cx input))), - (Core.Name "list", (\input -> Eithers.map (\t -> Core.TermList t) (Helpers.decodeList term cx input))), - (Core.Name "literal", (\input -> Eithers.map (\t -> Core.TermLiteral t) (literal cx input))), - (Core.Name "map", (\input -> Eithers.map (\t -> Core.TermMap t) (Helpers.decodeMap term term cx input))), - (Core.Name "maybe", (\input -> Eithers.map (\t -> Core.TermMaybe t) (Helpers.decodeMaybe term cx input))), - (Core.Name "pair", (\input -> Eithers.map (\t -> Core.TermPair t) (Helpers.decodePair term term cx input))), - (Core.Name "record", (\input -> Eithers.map (\t -> Core.TermRecord t) (record cx input))), - (Core.Name "set", (\input -> Eithers.map (\t -> Core.TermSet t) (Helpers.decodeSet term cx input))), - (Core.Name "typeApplication", (\input -> Eithers.map (\t -> Core.TermTypeApplication t) (typeApplicationTerm cx input))), - (Core.Name "typeLambda", (\input -> Eithers.map (\t -> Core.TermTypeLambda t) (typeLambda cx input))), - (Core.Name "union", (\input -> Eithers.map (\t -> Core.TermUnion t) (injection cx input))), - (Core.Name "unit", (\input -> Eithers.map (\t -> Core.TermUnit) (Helpers.decodeUnit cx input))), - (Core.Name "variable", (\input -> Eithers.map (\t -> Core.TermVariable t) (name cx input))), - (Core.Name "wrap", (\input -> Eithers.map (\t -> Core.TermWrap t) (wrappedTerm cx input)))] - in (Maybes.maybe (Left (Errors.DecodingError (Strings.cat [ - "no such field ", - (Core.unName fname), - " in union"]))) (\f -> f fterm) (Maps.lookup fname variantMap)) - _ -> Left (Errors.DecodingError "expected union")) (Lexical.stripAndDereferenceTermEither cx raw) - -type_ :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.Type -type_ cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermUnion v0 -> - let field = Core.injectionField v0 - fname = Core.fieldName field - fterm = Core.fieldTerm field - variantMap = - Maps.fromList [ - (Core.Name "annotated", (\input -> Eithers.map (\t -> Core.TypeAnnotated t) (annotatedType cx input))), - (Core.Name "application", (\input -> Eithers.map (\t -> Core.TypeApplication t) (applicationType cx input))), - (Core.Name "either", (\input -> Eithers.map (\t -> Core.TypeEither t) (eitherType cx input))), - (Core.Name "forall", (\input -> Eithers.map (\t -> Core.TypeForall t) (forallType cx input))), - (Core.Name "function", (\input -> Eithers.map (\t -> Core.TypeFunction t) (functionType cx input))), - (Core.Name "list", (\input -> Eithers.map (\t -> Core.TypeList t) (type_ cx input))), - (Core.Name "literal", (\input -> Eithers.map (\t -> Core.TypeLiteral t) (literalType cx input))), - (Core.Name "map", (\input -> Eithers.map (\t -> Core.TypeMap t) (mapType cx input))), - (Core.Name "maybe", (\input -> Eithers.map (\t -> Core.TypeMaybe t) (type_ cx input))), - (Core.Name "pair", (\input -> Eithers.map (\t -> Core.TypePair t) (pairType cx input))), - (Core.Name "record", (\input -> Eithers.map (\t -> Core.TypeRecord t) (Helpers.decodeList fieldType cx input))), - (Core.Name "set", (\input -> Eithers.map (\t -> Core.TypeSet t) (type_ cx input))), - (Core.Name "union", (\input -> Eithers.map (\t -> Core.TypeUnion t) (Helpers.decodeList fieldType cx input))), - (Core.Name "unit", (\input -> Eithers.map (\t -> Core.TypeUnit) (Helpers.decodeUnit cx input))), - (Core.Name "variable", (\input -> Eithers.map (\t -> Core.TypeVariable t) (name cx input))), - (Core.Name "void", (\input -> Eithers.map (\t -> Core.TypeVoid) (Helpers.decodeUnit cx input))), - (Core.Name "wrap", (\input -> Eithers.map (\t -> Core.TypeWrap t) (type_ cx input)))] - in (Maybes.maybe (Left (Errors.DecodingError (Strings.cat [ - "no such field ", - (Core.unName fname), - " in union"]))) (\f -> f fterm) (Maps.lookup fname variantMap)) - _ -> Left (Errors.DecodingError "expected union")) (Lexical.stripAndDereferenceTermEither cx raw) - -typeApplicationTerm :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.TypeApplicationTerm -typeApplicationTerm cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "body" term fieldMap cx) (\field_body -> Eithers.bind (Helpers.requireField "type" type_ fieldMap cx) (\field_type -> Right (Core.TypeApplicationTerm { - Core.typeApplicationTermBody = field_body, - Core.typeApplicationTermType = field_type})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -typeLambda :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.TypeLambda -typeLambda cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "parameter" name fieldMap cx) (\field_parameter -> Eithers.bind (Helpers.requireField "body" term fieldMap cx) (\field_body -> Right (Core.TypeLambda { - Core.typeLambdaParameter = field_parameter, - Core.typeLambdaBody = field_body})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -typeScheme :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.TypeScheme -typeScheme cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "variables" (Helpers.decodeList name) fieldMap cx) (\field_variables -> Eithers.bind (Helpers.requireField "type" type_ fieldMap cx) (\field_type -> Eithers.bind (Helpers.requireField "constraints" (Helpers.decodeMaybe (Helpers.decodeMap name typeVariableMetadata)) fieldMap cx) (\field_constraints -> Right (Core.TypeScheme { - Core.typeSchemeVariables = field_variables, - Core.typeSchemeType = field_type, - Core.typeSchemeConstraints = field_constraints}))))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -typeVariableMetadata :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.TypeVariableMetadata -typeVariableMetadata cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "classes" (Helpers.decodeSet name) fieldMap cx) (\field_classes -> Right (Core.TypeVariableMetadata { - Core.typeVariableMetadataClasses = field_classes}))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -wrappedTerm :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.WrappedTerm -wrappedTerm cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "typeName" name fieldMap cx) (\field_typeName -> Eithers.bind (Helpers.requireField "body" term fieldMap cx) (\field_body -> Right (Core.WrappedTerm { - Core.wrappedTermTypeName = field_typeName, - Core.wrappedTermBody = field_body})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) diff --git a/src/gen-main/haskell/Hydra/Decode/Error/Checking.hs b/src/gen-main/haskell/Hydra/Decode/Error/Checking.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Decode/Error/Checking.hs +++ /dev/null @@ -1,163 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Term decoders for hydra.error.checking - -module Hydra.Decode.Error.Checking where - -import qualified Hydra.Core as Core -import qualified Hydra.Decode.Core as Core_ -import qualified Hydra.Decode.Typing as Typing -import qualified Hydra.Decode.Variants as Variants -import qualified Hydra.Error.Checking as Checking -import qualified Hydra.Errors as Errors -import qualified Hydra.Extract.Helpers as Helpers -import qualified Hydra.Graph as Graph -import qualified Hydra.Lexical as Lexical -import qualified Hydra.Lib.Eithers as Eithers -import qualified Hydra.Lib.Maps as Maps -import qualified Hydra.Lib.Maybes as Maybes -import qualified Hydra.Lib.Strings as Strings -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -checkingError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Checking.CheckingError -checkingError cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermUnion v0 -> - let field = Core.injectionField v0 - fname = Core.fieldName field - fterm = Core.fieldTerm field - variantMap = - Maps.fromList [ - (Core.Name "incorrectUnification", (\input -> Eithers.map (\t -> Checking.CheckingErrorIncorrectUnification t) (incorrectUnificationError cx input))), - (Core.Name "notAForallType", (\input -> Eithers.map (\t -> Checking.CheckingErrorNotAForallType t) (notAForallTypeError cx input))), - (Core.Name "notAFunctionType", (\input -> Eithers.map (\t -> Checking.CheckingErrorNotAFunctionType t) (notAFunctionTypeError cx input))), - (Core.Name "typeArityMismatch", (\input -> Eithers.map (\t -> Checking.CheckingErrorTypeArityMismatch t) (typeArityMismatchError cx input))), - (Core.Name "typeMismatch", (\input -> Eithers.map (\t -> Checking.CheckingErrorTypeMismatch t) (typeMismatchError cx input))), - (Core.Name "unboundTypeVariables", (\input -> Eithers.map (\t -> Checking.CheckingErrorUnboundTypeVariables t) (unboundTypeVariablesError cx input))), - (Core.Name "unequalTypes", (\input -> Eithers.map (\t -> Checking.CheckingErrorUnequalTypes t) (unequalTypesError cx input))), - (Core.Name "unsupportedTermVariant", (\input -> Eithers.map (\t -> Checking.CheckingErrorUnsupportedTermVariant t) (unsupportedTermVariantError cx input))), - (Core.Name "untypedLambda", (\input -> Eithers.map (\t -> Checking.CheckingErrorUntypedLambda t) (untypedLambdaError cx input))), - (Core.Name "untypedLetBinding", (\input -> Eithers.map (\t -> Checking.CheckingErrorUntypedLetBinding t) (untypedLetBindingError cx input)))] - in (Maybes.maybe (Left (Errors.DecodingError (Strings.cat [ - "no such field ", - (Core.unName fname), - " in union"]))) (\f -> f fterm) (Maps.lookup fname variantMap)) - _ -> Left (Errors.DecodingError "expected union")) (Lexical.stripAndDereferenceTermEither cx raw) - -incorrectUnificationError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Checking.IncorrectUnificationError -incorrectUnificationError cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "substitution" Typing.typeSubst fieldMap cx) (\field_substitution -> Right (Checking.IncorrectUnificationError { - Checking.incorrectUnificationErrorSubstitution = field_substitution}))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -notAForallTypeError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Checking.NotAForallTypeError -notAForallTypeError cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "type" Core_.type_ fieldMap cx) (\field_type -> Eithers.bind (Helpers.requireField "typeArguments" (Helpers.decodeList Core_.type_) fieldMap cx) (\field_typeArguments -> Right (Checking.NotAForallTypeError { - Checking.notAForallTypeErrorType = field_type, - Checking.notAForallTypeErrorTypeArguments = field_typeArguments})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -notAFunctionTypeError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Checking.NotAFunctionTypeError -notAFunctionTypeError cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "type" Core_.type_ fieldMap cx) (\field_type -> Right (Checking.NotAFunctionTypeError { - Checking.notAFunctionTypeErrorType = field_type}))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -typeArityMismatchError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Checking.TypeArityMismatchError -typeArityMismatchError cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "type" Core_.type_ fieldMap cx) (\field_type -> Eithers.bind (Helpers.requireField "expectedArity" (\cx -> \raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralInteger v2 -> case v2 of - Core.IntegerValueInt32 v3 -> Right v3 - _ -> Left (Errors.DecodingError "expected int32 value") - _ -> Left (Errors.DecodingError "expected int32 literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw)) fieldMap cx) (\field_expectedArity -> Eithers.bind (Helpers.requireField "actualArity" (\cx -> \raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralInteger v2 -> case v2 of - Core.IntegerValueInt32 v3 -> Right v3 - _ -> Left (Errors.DecodingError "expected int32 value") - _ -> Left (Errors.DecodingError "expected int32 literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw)) fieldMap cx) (\field_actualArity -> Eithers.bind (Helpers.requireField "typeArguments" (Helpers.decodeList Core_.type_) fieldMap cx) (\field_typeArguments -> Right (Checking.TypeArityMismatchError { - Checking.typeArityMismatchErrorType = field_type, - Checking.typeArityMismatchErrorExpectedArity = field_expectedArity, - Checking.typeArityMismatchErrorActualArity = field_actualArity, - Checking.typeArityMismatchErrorTypeArguments = field_typeArguments})))))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -typeMismatchError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Checking.TypeMismatchError -typeMismatchError cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "expectedType" Core_.type_ fieldMap cx) (\field_expectedType -> Eithers.bind (Helpers.requireField "actualType" Core_.type_ fieldMap cx) (\field_actualType -> Right (Checking.TypeMismatchError { - Checking.typeMismatchErrorExpectedType = field_expectedType, - Checking.typeMismatchErrorActualType = field_actualType})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -unboundTypeVariablesError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Checking.UnboundTypeVariablesError -unboundTypeVariablesError cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "variables" (Helpers.decodeSet Core_.name) fieldMap cx) (\field_variables -> Eithers.bind (Helpers.requireField "type" Core_.type_ fieldMap cx) (\field_type -> Right (Checking.UnboundTypeVariablesError { - Checking.unboundTypeVariablesErrorVariables = field_variables, - Checking.unboundTypeVariablesErrorType = field_type})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -unequalTypesError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Checking.UnequalTypesError -unequalTypesError cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "types" (Helpers.decodeList Core_.type_) fieldMap cx) (\field_types -> Eithers.bind (Helpers.requireField "description" (\cx -> \raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw)) fieldMap cx) (\field_description -> Right (Checking.UnequalTypesError { - Checking.unequalTypesErrorTypes = field_types, - Checking.unequalTypesErrorDescription = field_description})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -unsupportedTermVariantError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Checking.UnsupportedTermVariantError -unsupportedTermVariantError cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "termVariant" Variants.termVariant fieldMap cx) (\field_termVariant -> Right (Checking.UnsupportedTermVariantError { - Checking.unsupportedTermVariantErrorTermVariant = field_termVariant}))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -untypedLambdaError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Checking.UntypedLambdaError -untypedLambdaError cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Right (Checking.UntypedLambdaError { - })) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -untypedLetBindingError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Checking.UntypedLetBindingError -untypedLetBindingError cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "binding" Core_.binding fieldMap cx) (\field_binding -> Right (Checking.UntypedLetBindingError { - Checking.untypedLetBindingErrorBinding = field_binding}))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) diff --git a/src/gen-main/haskell/Hydra/Decode/Error/Core.hs b/src/gen-main/haskell/Hydra/Decode/Error/Core.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Decode/Error/Core.hs +++ /dev/null @@ -1,475 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Term decoders for hydra.error.core - -module Hydra.Decode.Error.Core where - -import qualified Hydra.Core as Core -import qualified Hydra.Decode.Core as Core_ -import qualified Hydra.Decode.Paths as Paths -import qualified Hydra.Decode.Variants as Variants -import qualified Hydra.Error.Core as Core__ -import qualified Hydra.Errors as Errors -import qualified Hydra.Extract.Helpers as Helpers -import qualified Hydra.Graph as Graph -import qualified Hydra.Lexical as Lexical -import qualified Hydra.Lib.Eithers as Eithers -import qualified Hydra.Lib.Maps as Maps -import qualified Hydra.Lib.Maybes as Maybes -import qualified Hydra.Lib.Strings as Strings -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -constantConditionError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core__.ConstantConditionError -constantConditionError cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Eithers.bind (Helpers.requireField "value" (\cx -> \raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralBoolean v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected boolean literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw)) fieldMap cx) (\field_value -> Right (Core__.ConstantConditionError { - Core__.constantConditionErrorLocation = field_location, - Core__.constantConditionErrorValue = field_value})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -duplicateBindingError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core__.DuplicateBindingError -duplicateBindingError cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Eithers.bind (Helpers.requireField "name" Core_.name fieldMap cx) (\field_name -> Right (Core__.DuplicateBindingError { - Core__.duplicateBindingErrorLocation = field_location, - Core__.duplicateBindingErrorName = field_name})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -duplicateFieldError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core__.DuplicateFieldError -duplicateFieldError cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Eithers.bind (Helpers.requireField "name" Core_.name fieldMap cx) (\field_name -> Right (Core__.DuplicateFieldError { - Core__.duplicateFieldErrorLocation = field_location, - Core__.duplicateFieldErrorName = field_name})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -duplicateRecordTypeFieldNamesError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core__.DuplicateRecordTypeFieldNamesError -duplicateRecordTypeFieldNamesError cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Eithers.bind (Helpers.requireField "name" Core_.name fieldMap cx) (\field_name -> Right (Core__.DuplicateRecordTypeFieldNamesError { - Core__.duplicateRecordTypeFieldNamesErrorLocation = field_location, - Core__.duplicateRecordTypeFieldNamesErrorName = field_name})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -duplicateUnionTypeFieldNamesError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core__.DuplicateUnionTypeFieldNamesError -duplicateUnionTypeFieldNamesError cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Eithers.bind (Helpers.requireField "name" Core_.name fieldMap cx) (\field_name -> Right (Core__.DuplicateUnionTypeFieldNamesError { - Core__.duplicateUnionTypeFieldNamesErrorLocation = field_location, - Core__.duplicateUnionTypeFieldNamesErrorName = field_name})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -emptyCaseStatementError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core__.EmptyCaseStatementError -emptyCaseStatementError cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Eithers.bind (Helpers.requireField "typeName" Core_.name fieldMap cx) (\field_typeName -> Right (Core__.EmptyCaseStatementError { - Core__.emptyCaseStatementErrorLocation = field_location, - Core__.emptyCaseStatementErrorTypeName = field_typeName})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -emptyLetBindingsError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core__.EmptyLetBindingsError -emptyLetBindingsError cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Right (Core__.EmptyLetBindingsError { - Core__.emptyLetBindingsErrorLocation = field_location}))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -emptyRecordTypeError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core__.EmptyRecordTypeError -emptyRecordTypeError cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Right (Core__.EmptyRecordTypeError { - Core__.emptyRecordTypeErrorLocation = field_location}))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -emptyTermAnnotationError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core__.EmptyTermAnnotationError -emptyTermAnnotationError cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Right (Core__.EmptyTermAnnotationError { - Core__.emptyTermAnnotationErrorLocation = field_location}))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -emptyTypeAnnotationError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core__.EmptyTypeAnnotationError -emptyTypeAnnotationError cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Right (Core__.EmptyTypeAnnotationError { - Core__.emptyTypeAnnotationErrorLocation = field_location}))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -emptyTypeNameInTermError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core__.EmptyTypeNameInTermError -emptyTypeNameInTermError cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Right (Core__.EmptyTypeNameInTermError { - Core__.emptyTypeNameInTermErrorLocation = field_location}))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -emptyUnionTypeError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core__.EmptyUnionTypeError -emptyUnionTypeError cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Right (Core__.EmptyUnionTypeError { - Core__.emptyUnionTypeErrorLocation = field_location}))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -invalidForallParameterNameError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core__.InvalidForallParameterNameError -invalidForallParameterNameError cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Eithers.bind (Helpers.requireField "name" Core_.name fieldMap cx) (\field_name -> Right (Core__.InvalidForallParameterNameError { - Core__.invalidForallParameterNameErrorLocation = field_location, - Core__.invalidForallParameterNameErrorName = field_name})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -invalidLambdaParameterNameError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core__.InvalidLambdaParameterNameError -invalidLambdaParameterNameError cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Eithers.bind (Helpers.requireField "name" Core_.name fieldMap cx) (\field_name -> Right (Core__.InvalidLambdaParameterNameError { - Core__.invalidLambdaParameterNameErrorLocation = field_location, - Core__.invalidLambdaParameterNameErrorName = field_name})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -invalidLetBindingNameError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core__.InvalidLetBindingNameError -invalidLetBindingNameError cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Eithers.bind (Helpers.requireField "name" Core_.name fieldMap cx) (\field_name -> Right (Core__.InvalidLetBindingNameError { - Core__.invalidLetBindingNameErrorLocation = field_location, - Core__.invalidLetBindingNameErrorName = field_name})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -invalidTermError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core__.InvalidTermError -invalidTermError cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermUnion v0 -> - let field = Core.injectionField v0 - fname = Core.fieldName field - fterm = Core.fieldTerm field - variantMap = - Maps.fromList [ - (Core.Name "constantCondition", (\input -> Eithers.map (\t -> Core__.InvalidTermErrorConstantCondition t) (constantConditionError cx input))), - (Core.Name "duplicateBinding", (\input -> Eithers.map (\t -> Core__.InvalidTermErrorDuplicateBinding t) (duplicateBindingError cx input))), - (Core.Name "duplicateField", (\input -> Eithers.map (\t -> Core__.InvalidTermErrorDuplicateField t) (duplicateFieldError cx input))), - (Core.Name "emptyCaseStatement", (\input -> Eithers.map (\t -> Core__.InvalidTermErrorEmptyCaseStatement t) (emptyCaseStatementError cx input))), - (Core.Name "emptyLetBindings", (\input -> Eithers.map (\t -> Core__.InvalidTermErrorEmptyLetBindings t) (emptyLetBindingsError cx input))), - (Core.Name "emptyTermAnnotation", (\input -> Eithers.map (\t -> Core__.InvalidTermErrorEmptyTermAnnotation t) (emptyTermAnnotationError cx input))), - (Core.Name "emptyTypeNameInTerm", (\input -> Eithers.map (\t -> Core__.InvalidTermErrorEmptyTypeNameInTerm t) (emptyTypeNameInTermError cx input))), - (Core.Name "invalidLambdaParameterName", (\input -> Eithers.map (\t -> Core__.InvalidTermErrorInvalidLambdaParameterName t) (invalidLambdaParameterNameError cx input))), - (Core.Name "invalidLetBindingName", (\input -> Eithers.map (\t -> Core__.InvalidTermErrorInvalidLetBindingName t) (invalidLetBindingNameError cx input))), - (Core.Name "invalidTypeLambdaParameterName", (\input -> Eithers.map (\t -> Core__.InvalidTermErrorInvalidTypeLambdaParameterName t) (invalidTypeLambdaParameterNameError cx input))), - (Core.Name "nestedTermAnnotation", (\input -> Eithers.map (\t -> Core__.InvalidTermErrorNestedTermAnnotation t) (nestedTermAnnotationError cx input))), - (Core.Name "redundantWrapUnwrap", (\input -> Eithers.map (\t -> Core__.InvalidTermErrorRedundantWrapUnwrap t) (redundantWrapUnwrapError cx input))), - (Core.Name "selfApplication", (\input -> Eithers.map (\t -> Core__.InvalidTermErrorSelfApplication t) (selfApplicationError cx input))), - (Core.Name "termVariableShadowing", (\input -> Eithers.map (\t -> Core__.InvalidTermErrorTermVariableShadowing t) (termVariableShadowingError cx input))), - (Core.Name "typeVariableShadowingInTypeLambda", (\input -> Eithers.map (\t -> Core__.InvalidTermErrorTypeVariableShadowingInTypeLambda t) (typeVariableShadowingInTypeLambdaError cx input))), - (Core.Name "undefinedTermVariable", (\input -> Eithers.map (\t -> Core__.InvalidTermErrorUndefinedTermVariable t) (undefinedTermVariableError cx input))), - (Core.Name "undefinedTypeVariableInBindingType", (\input -> Eithers.map (\t -> Core__.InvalidTermErrorUndefinedTypeVariableInBindingType t) (undefinedTypeVariableInBindingTypeError cx input))), - (Core.Name "undefinedTypeVariableInLambdaDomain", (\input -> Eithers.map (\t -> Core__.InvalidTermErrorUndefinedTypeVariableInLambdaDomain t) (undefinedTypeVariableInLambdaDomainError cx input))), - (Core.Name "undefinedTypeVariableInTypeApplication", (\input -> Eithers.map (\t -> Core__.InvalidTermErrorUndefinedTypeVariableInTypeApplication t) (undefinedTypeVariableInTypeApplicationError cx input))), - (Core.Name "unknownPrimitiveName", (\input -> Eithers.map (\t -> Core__.InvalidTermErrorUnknownPrimitiveName t) (unknownPrimitiveNameError cx input))), - (Core.Name "unnecessaryIdentityApplication", (\input -> Eithers.map (\t -> Core__.InvalidTermErrorUnnecessaryIdentityApplication t) (unnecessaryIdentityApplicationError cx input))), - (Core.Name "untypedTermVariable", (\input -> Eithers.map (\t -> Core__.InvalidTermErrorUntypedTermVariable t) (untypedTermVariableError cx input)))] - in (Maybes.maybe (Left (Errors.DecodingError (Strings.cat [ - "no such field ", - (Core.unName fname), - " in union"]))) (\f -> f fterm) (Maps.lookup fname variantMap)) - _ -> Left (Errors.DecodingError "expected union")) (Lexical.stripAndDereferenceTermEither cx raw) - -invalidTypeError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core__.InvalidTypeError -invalidTypeError cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermUnion v0 -> - let field = Core.injectionField v0 - fname = Core.fieldName field - fterm = Core.fieldTerm field - variantMap = - Maps.fromList [ - (Core.Name "duplicateRecordTypeFieldNames", (\input -> Eithers.map (\t -> Core__.InvalidTypeErrorDuplicateRecordTypeFieldNames t) (duplicateRecordTypeFieldNamesError cx input))), - (Core.Name "duplicateUnionTypeFieldNames", (\input -> Eithers.map (\t -> Core__.InvalidTypeErrorDuplicateUnionTypeFieldNames t) (duplicateUnionTypeFieldNamesError cx input))), - (Core.Name "emptyRecordType", (\input -> Eithers.map (\t -> Core__.InvalidTypeErrorEmptyRecordType t) (emptyRecordTypeError cx input))), - (Core.Name "emptyTypeAnnotation", (\input -> Eithers.map (\t -> Core__.InvalidTypeErrorEmptyTypeAnnotation t) (emptyTypeAnnotationError cx input))), - (Core.Name "emptyUnionType", (\input -> Eithers.map (\t -> Core__.InvalidTypeErrorEmptyUnionType t) (emptyUnionTypeError cx input))), - (Core.Name "invalidForallParameterName", (\input -> Eithers.map (\t -> Core__.InvalidTypeErrorInvalidForallParameterName t) (invalidForallParameterNameError cx input))), - (Core.Name "invalidTypeSchemeVariableName", (\input -> Eithers.map (\t -> Core__.InvalidTypeErrorInvalidTypeSchemeVariableName t) (invalidTypeSchemeVariableNameError cx input))), - (Core.Name "nestedTypeAnnotation", (\input -> Eithers.map (\t -> Core__.InvalidTypeErrorNestedTypeAnnotation t) (nestedTypeAnnotationError cx input))), - (Core.Name "nonComparableMapKeyType", (\input -> Eithers.map (\t -> Core__.InvalidTypeErrorNonComparableMapKeyType t) (nonComparableMapKeyTypeError cx input))), - (Core.Name "nonComparableSetElementType", (\input -> Eithers.map (\t -> Core__.InvalidTypeErrorNonComparableSetElementType t) (nonComparableSetElementTypeError cx input))), - (Core.Name "singleVariantUnion", (\input -> Eithers.map (\t -> Core__.InvalidTypeErrorSingleVariantUnion t) (singleVariantUnionError cx input))), - (Core.Name "typeVariableShadowingInForall", (\input -> Eithers.map (\t -> Core__.InvalidTypeErrorTypeVariableShadowingInForall t) (typeVariableShadowingInForallError cx input))), - (Core.Name "undefinedTypeVariable", (\input -> Eithers.map (\t -> Core__.InvalidTypeErrorUndefinedTypeVariable t) (undefinedTypeVariableError cx input))), - (Core.Name "voidInNonBottomPosition", (\input -> Eithers.map (\t -> Core__.InvalidTypeErrorVoidInNonBottomPosition t) (voidInNonBottomPositionError cx input)))] - in (Maybes.maybe (Left (Errors.DecodingError (Strings.cat [ - "no such field ", - (Core.unName fname), - " in union"]))) (\f -> f fterm) (Maps.lookup fname variantMap)) - _ -> Left (Errors.DecodingError "expected union")) (Lexical.stripAndDereferenceTermEither cx raw) - -invalidTypeLambdaParameterNameError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core__.InvalidTypeLambdaParameterNameError -invalidTypeLambdaParameterNameError cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Eithers.bind (Helpers.requireField "name" Core_.name fieldMap cx) (\field_name -> Right (Core__.InvalidTypeLambdaParameterNameError { - Core__.invalidTypeLambdaParameterNameErrorLocation = field_location, - Core__.invalidTypeLambdaParameterNameErrorName = field_name})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -invalidTypeSchemeVariableNameError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core__.InvalidTypeSchemeVariableNameError -invalidTypeSchemeVariableNameError cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Eithers.bind (Helpers.requireField "name" Core_.name fieldMap cx) (\field_name -> Right (Core__.InvalidTypeSchemeVariableNameError { - Core__.invalidTypeSchemeVariableNameErrorLocation = field_location, - Core__.invalidTypeSchemeVariableNameErrorName = field_name})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -nestedTermAnnotationError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core__.NestedTermAnnotationError -nestedTermAnnotationError cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Right (Core__.NestedTermAnnotationError { - Core__.nestedTermAnnotationErrorLocation = field_location}))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -nestedTypeAnnotationError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core__.NestedTypeAnnotationError -nestedTypeAnnotationError cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Right (Core__.NestedTypeAnnotationError { - Core__.nestedTypeAnnotationErrorLocation = field_location}))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -nonComparableMapKeyTypeError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core__.NonComparableMapKeyTypeError -nonComparableMapKeyTypeError cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Eithers.bind (Helpers.requireField "keyType" Core_.type_ fieldMap cx) (\field_keyType -> Right (Core__.NonComparableMapKeyTypeError { - Core__.nonComparableMapKeyTypeErrorLocation = field_location, - Core__.nonComparableMapKeyTypeErrorKeyType = field_keyType})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -nonComparableSetElementTypeError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core__.NonComparableSetElementTypeError -nonComparableSetElementTypeError cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Eithers.bind (Helpers.requireField "elementType" Core_.type_ fieldMap cx) (\field_elementType -> Right (Core__.NonComparableSetElementTypeError { - Core__.nonComparableSetElementTypeErrorLocation = field_location, - Core__.nonComparableSetElementTypeErrorElementType = field_elementType})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -redundantWrapUnwrapError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core__.RedundantWrapUnwrapError -redundantWrapUnwrapError cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Eithers.bind (Helpers.requireField "typeName" Core_.name fieldMap cx) (\field_typeName -> Right (Core__.RedundantWrapUnwrapError { - Core__.redundantWrapUnwrapErrorLocation = field_location, - Core__.redundantWrapUnwrapErrorTypeName = field_typeName})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -selfApplicationError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core__.SelfApplicationError -selfApplicationError cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Eithers.bind (Helpers.requireField "name" Core_.name fieldMap cx) (\field_name -> Right (Core__.SelfApplicationError { - Core__.selfApplicationErrorLocation = field_location, - Core__.selfApplicationErrorName = field_name})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -singleVariantUnionError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core__.SingleVariantUnionError -singleVariantUnionError cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Eithers.bind (Helpers.requireField "fieldName" Core_.name fieldMap cx) (\field_fieldName -> Right (Core__.SingleVariantUnionError { - Core__.singleVariantUnionErrorLocation = field_location, - Core__.singleVariantUnionErrorFieldName = field_fieldName})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -termVariableShadowingError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core__.TermVariableShadowingError -termVariableShadowingError cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Eithers.bind (Helpers.requireField "name" Core_.name fieldMap cx) (\field_name -> Right (Core__.TermVariableShadowingError { - Core__.termVariableShadowingErrorLocation = field_location, - Core__.termVariableShadowingErrorName = field_name})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -typeVariableShadowingInForallError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core__.TypeVariableShadowingInForallError -typeVariableShadowingInForallError cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Eithers.bind (Helpers.requireField "name" Core_.name fieldMap cx) (\field_name -> Right (Core__.TypeVariableShadowingInForallError { - Core__.typeVariableShadowingInForallErrorLocation = field_location, - Core__.typeVariableShadowingInForallErrorName = field_name})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -typeVariableShadowingInTypeLambdaError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core__.TypeVariableShadowingInTypeLambdaError -typeVariableShadowingInTypeLambdaError cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Eithers.bind (Helpers.requireField "name" Core_.name fieldMap cx) (\field_name -> Right (Core__.TypeVariableShadowingInTypeLambdaError { - Core__.typeVariableShadowingInTypeLambdaErrorLocation = field_location, - Core__.typeVariableShadowingInTypeLambdaErrorName = field_name})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -undefinedFieldError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core__.UndefinedFieldError -undefinedFieldError cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "fieldName" Core_.name fieldMap cx) (\field_fieldName -> Eithers.bind (Helpers.requireField "typeName" Core_.name fieldMap cx) (\field_typeName -> Right (Core__.UndefinedFieldError { - Core__.undefinedFieldErrorFieldName = field_fieldName, - Core__.undefinedFieldErrorTypeName = field_typeName})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -undefinedTermVariableError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core__.UndefinedTermVariableError -undefinedTermVariableError cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Eithers.bind (Helpers.requireField "name" Core_.name fieldMap cx) (\field_name -> Right (Core__.UndefinedTermVariableError { - Core__.undefinedTermVariableErrorLocation = field_location, - Core__.undefinedTermVariableErrorName = field_name})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -undefinedTypeVariableError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core__.UndefinedTypeVariableError -undefinedTypeVariableError cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Eithers.bind (Helpers.requireField "name" Core_.name fieldMap cx) (\field_name -> Right (Core__.UndefinedTypeVariableError { - Core__.undefinedTypeVariableErrorLocation = field_location, - Core__.undefinedTypeVariableErrorName = field_name})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -undefinedTypeVariableInBindingTypeError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core__.UndefinedTypeVariableInBindingTypeError -undefinedTypeVariableInBindingTypeError cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Eithers.bind (Helpers.requireField "name" Core_.name fieldMap cx) (\field_name -> Right (Core__.UndefinedTypeVariableInBindingTypeError { - Core__.undefinedTypeVariableInBindingTypeErrorLocation = field_location, - Core__.undefinedTypeVariableInBindingTypeErrorName = field_name})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -undefinedTypeVariableInLambdaDomainError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core__.UndefinedTypeVariableInLambdaDomainError -undefinedTypeVariableInLambdaDomainError cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Eithers.bind (Helpers.requireField "name" Core_.name fieldMap cx) (\field_name -> Right (Core__.UndefinedTypeVariableInLambdaDomainError { - Core__.undefinedTypeVariableInLambdaDomainErrorLocation = field_location, - Core__.undefinedTypeVariableInLambdaDomainErrorName = field_name})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -undefinedTypeVariableInTypeApplicationError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core__.UndefinedTypeVariableInTypeApplicationError -undefinedTypeVariableInTypeApplicationError cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Eithers.bind (Helpers.requireField "name" Core_.name fieldMap cx) (\field_name -> Right (Core__.UndefinedTypeVariableInTypeApplicationError { - Core__.undefinedTypeVariableInTypeApplicationErrorLocation = field_location, - Core__.undefinedTypeVariableInTypeApplicationErrorName = field_name})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -unexpectedTermVariantError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core__.UnexpectedTermVariantError -unexpectedTermVariantError cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "expectedVariant" Variants.termVariant fieldMap cx) (\field_expectedVariant -> Eithers.bind (Helpers.requireField "actualTerm" Core_.term fieldMap cx) (\field_actualTerm -> Right (Core__.UnexpectedTermVariantError { - Core__.unexpectedTermVariantErrorExpectedVariant = field_expectedVariant, - Core__.unexpectedTermVariantErrorActualTerm = field_actualTerm})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -unexpectedTypeVariantError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core__.UnexpectedTypeVariantError -unexpectedTypeVariantError cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "expectedVariant" Variants.typeVariant fieldMap cx) (\field_expectedVariant -> Eithers.bind (Helpers.requireField "actualType" Core_.type_ fieldMap cx) (\field_actualType -> Right (Core__.UnexpectedTypeVariantError { - Core__.unexpectedTypeVariantErrorExpectedVariant = field_expectedVariant, - Core__.unexpectedTypeVariantErrorActualType = field_actualType})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -unknownPrimitiveNameError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core__.UnknownPrimitiveNameError -unknownPrimitiveNameError cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Eithers.bind (Helpers.requireField "name" Core_.name fieldMap cx) (\field_name -> Right (Core__.UnknownPrimitiveNameError { - Core__.unknownPrimitiveNameErrorLocation = field_location, - Core__.unknownPrimitiveNameErrorName = field_name})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -unnecessaryIdentityApplicationError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core__.UnnecessaryIdentityApplicationError -unnecessaryIdentityApplicationError cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Right (Core__.UnnecessaryIdentityApplicationError { - Core__.unnecessaryIdentityApplicationErrorLocation = field_location}))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -untypedTermVariableError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core__.UntypedTermVariableError -untypedTermVariableError cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Eithers.bind (Helpers.requireField "name" Core_.name fieldMap cx) (\field_name -> Right (Core__.UntypedTermVariableError { - Core__.untypedTermVariableErrorLocation = field_location, - Core__.untypedTermVariableErrorName = field_name})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -voidInNonBottomPositionError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core__.VoidInNonBottomPositionError -voidInNonBottomPositionError cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Right (Core__.VoidInNonBottomPositionError { - Core__.voidInNonBottomPositionErrorLocation = field_location}))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) diff --git a/src/gen-main/haskell/Hydra/Decode/Errors.hs b/src/gen-main/haskell/Hydra/Decode/Errors.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Decode/Errors.hs +++ /dev/null @@ -1,85 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Term decoders for hydra.errors - -module Hydra.Decode.Errors where - -import qualified Hydra.Core as Core -import qualified Hydra.Decode.Core as Core_ -import qualified Hydra.Decode.Error.Checking as Checking -import qualified Hydra.Decode.Error.Core as Core__ -import qualified Hydra.Errors as Errors -import qualified Hydra.Extract.Helpers as Helpers -import qualified Hydra.Graph as Graph -import qualified Hydra.Lexical as Lexical -import qualified Hydra.Lib.Eithers as Eithers -import qualified Hydra.Lib.Maps as Maps -import qualified Hydra.Lib.Maybes as Maybes -import qualified Hydra.Lib.Strings as Strings -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -decodingError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Errors.DecodingError -decodingError cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermWrap v0 -> Eithers.map (\b -> Errors.DecodingError b) ((\raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw)) (Core.wrappedTermBody v0)) - _ -> Left (Errors.DecodingError "expected wrapped type")) (Lexical.stripAndDereferenceTermEither cx raw) - -error :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Errors.Error -error cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermUnion v0 -> - let field = Core.injectionField v0 - fname = Core.fieldName field - fterm = Core.fieldTerm field - variantMap = - Maps.fromList [ - (Core.Name "checking", (\input -> Eithers.map (\t -> Errors.ErrorChecking t) (Checking.checkingError cx input))), - (Core.Name "decoding", (\input -> Eithers.map (\t -> Errors.ErrorDecoding t) (decodingError cx input))), - (Core.Name "duplicateBinding", (\input -> Eithers.map (\t -> Errors.ErrorDuplicateBinding t) (Core__.duplicateBindingError cx input))), - (Core.Name "duplicateField", (\input -> Eithers.map (\t -> Errors.ErrorDuplicateField t) (Core__.duplicateFieldError cx input))), - (Core.Name "other", (\input -> Eithers.map (\t -> Errors.ErrorOther t) (otherError cx input))), - (Core.Name "undefinedField", (\input -> Eithers.map (\t -> Errors.ErrorUndefinedField t) (Core__.undefinedFieldError cx input))), - (Core.Name "undefinedTermVariable", (\input -> Eithers.map (\t -> Errors.ErrorUndefinedTermVariable t) (Core__.undefinedTermVariableError cx input))), - (Core.Name "untypedTermVariable", (\input -> Eithers.map (\t -> Errors.ErrorUntypedTermVariable t) (Core__.untypedTermVariableError cx input))), - (Core.Name "unexpectedTermVariant", (\input -> Eithers.map (\t -> Errors.ErrorUnexpectedTermVariant t) (Core__.unexpectedTermVariantError cx input))), - (Core.Name "unexpectedTypeVariant", (\input -> Eithers.map (\t -> Errors.ErrorUnexpectedTypeVariant t) (Core__.unexpectedTypeVariantError cx input))), - (Core.Name "unification", (\input -> Eithers.map (\t -> Errors.ErrorUnification t) (unificationError cx input)))] - in (Maybes.maybe (Left (Errors.DecodingError (Strings.cat [ - "no such field ", - (Core.unName fname), - " in union"]))) (\f -> f fterm) (Maps.lookup fname variantMap)) - _ -> Left (Errors.DecodingError "expected union")) (Lexical.stripAndDereferenceTermEither cx raw) - -otherError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Errors.OtherError -otherError cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermWrap v0 -> Eithers.map (\b -> Errors.OtherError b) ((\raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw)) (Core.wrappedTermBody v0)) - _ -> Left (Errors.DecodingError "expected wrapped type")) (Lexical.stripAndDereferenceTermEither cx raw) - -unificationError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Errors.UnificationError -unificationError cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "leftType" Core_.type_ fieldMap cx) (\field_leftType -> Eithers.bind (Helpers.requireField "rightType" Core_.type_ fieldMap cx) (\field_rightType -> Eithers.bind (Helpers.requireField "message" (\cx -> \raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw)) fieldMap cx) (\field_message -> Right (Errors.UnificationError { - Errors.unificationErrorLeftType = field_leftType, - Errors.unificationErrorRightType = field_rightType, - Errors.unificationErrorMessage = field_message}))))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) diff --git a/src/gen-main/haskell/Hydra/Decode/Json.hs b/src/gen-main/haskell/Hydra/Decode/Json.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Decode/Json.hs +++ /dev/null @@ -1,61 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Term decoders for hydra.json - -module Hydra.Decode.Json where - -import qualified Hydra.Core as Core -import qualified Hydra.Extract.Helpers as Helpers -import qualified Hydra.Graph as Graph -import qualified Hydra.Json.Model as Model -import qualified Hydra.Lexical as Lexical -import qualified Hydra.Lib.Eithers as Eithers -import qualified Hydra.Lib.Maps as Maps -import qualified Hydra.Lib.Maybes as Maybes -import qualified Hydra.Lib.Strings as Strings -import qualified Hydra.Errors as Error -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -value :: (Graph.Graph -> Core.Term -> Either Error.DecodingError Model.Value) -value cx raw = (Eithers.either (\err -> Left (Error.DecodingError err)) (\stripped -> (\x -> case x of - Core.TermUnion v1 -> - let tname = (Core.injectionTypeName v1) - field = (Core.injectionField v1) - fname = (Core.fieldName field) - fterm = (Core.fieldTerm field) - variantMap = (Maps.fromList [ - (Core.Name "array", (\input -> Eithers.map (\t -> Model.ValueArray t) (Helpers.decodeList value cx input))), - (Core.Name "boolean", (\input -> Eithers.map (\t -> Model.ValueBoolean t) (Eithers.either (\err -> Left (Error.DecodingError err)) (\stripped -> (\x -> case x of - Core.TermLiteral v2 -> ((\x -> case x of - Core.LiteralBoolean v3 -> (Right v3) - _ -> (Left (Error.DecodingError "expected boolean literal"))) v2) - _ -> (Left (Error.DecodingError "expected literal"))) stripped) (Lexical.stripAndDereferenceTermEither cx input)))), - (Core.Name "null", (\input -> Eithers.map (\t -> Model.ValueNull) (Helpers.decodeUnit cx input))), - (Core.Name "number", (\input -> Eithers.map (\t -> Model.ValueNumber t) (Eithers.either (\err -> Left (Error.DecodingError err)) (\stripped -> (\x -> case x of - Core.TermLiteral v2 -> ((\x -> case x of - Core.LiteralFloat v3 -> ((\x -> case x of - Core.FloatValueBigfloat v4 -> (Right v4) - _ -> (Left (Error.DecodingError "expected bigfloat value"))) v3) - _ -> (Left (Error.DecodingError "expected bigfloat literal"))) v2) - _ -> (Left (Error.DecodingError "expected literal"))) stripped) (Lexical.stripAndDereferenceTermEither cx input)))), - (Core.Name "object", (\input -> Eithers.map (\t -> Model.ValueObject t) (Helpers.decodeMap (\cx -> \raw -> Eithers.either (\err -> Left (Error.DecodingError err)) (\stripped -> (\x -> case x of - Core.TermLiteral v2 -> ((\x -> case x of - Core.LiteralString v3 -> (Right v3) - _ -> (Left (Error.DecodingError "expected string literal"))) v2) - _ -> (Left (Error.DecodingError "expected literal"))) stripped) (Lexical.stripAndDereferenceTermEither cx raw)) value cx input))), - (Core.Name "string", (\input -> Eithers.map (\t -> Model.ValueString t) (Eithers.either (\err -> Left (Error.DecodingError err)) (\stripped -> (\x -> case x of - Core.TermLiteral v2 -> ((\x -> case x of - Core.LiteralString v3 -> (Right v3) - _ -> (Left (Error.DecodingError "expected string literal"))) v2) - _ -> (Left (Error.DecodingError "expected literal"))) stripped) (Lexical.stripAndDereferenceTermEither cx input))))]) - in (Maybes.maybe (Left (Error.DecodingError (Strings.cat [ - "no such field ", - (Core.unName fname), - " in union type ", - (Core.unName tname)]))) (\f -> f fterm) (Maps.lookup fname variantMap)) - _ -> (Left (Error.DecodingError "expected union of type hydra.json.model.Value"))) stripped) (Lexical.stripAndDereferenceTermEither cx raw)) diff --git a/src/gen-main/haskell/Hydra/Decode/Json/Model.hs b/src/gen-main/haskell/Hydra/Decode/Json/Model.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Decode/Json/Model.hs +++ /dev/null @@ -1,61 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Term decoders for hydra.json.model - -module Hydra.Decode.Json.Model where - -import qualified Hydra.Core as Core -import qualified Hydra.Errors as Errors -import qualified Hydra.Extract.Helpers as Helpers -import qualified Hydra.Graph as Graph -import qualified Hydra.Json.Model as Model -import qualified Hydra.Lexical as Lexical -import qualified Hydra.Lib.Eithers as Eithers -import qualified Hydra.Lib.Maps as Maps -import qualified Hydra.Lib.Maybes as Maybes -import qualified Hydra.Lib.Strings as Strings -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -value :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Model.Value -value cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermUnion v0 -> - let field = Core.injectionField v0 - fname = Core.fieldName field - fterm = Core.fieldTerm field - variantMap = - Maps.fromList [ - (Core.Name "array", (\input -> Eithers.map (\t -> Model.ValueArray t) (Helpers.decodeList value cx input))), - (Core.Name "boolean", (\input -> Eithers.map (\t -> Model.ValueBoolean t) (Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralBoolean v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected boolean literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx input)))), - (Core.Name "null", (\input -> Eithers.map (\t -> Model.ValueNull) (Helpers.decodeUnit cx input))), - (Core.Name "number", (\input -> Eithers.map (\t -> Model.ValueNumber t) (Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralFloat v2 -> case v2 of - Core.FloatValueBigfloat v3 -> Right v3 - _ -> Left (Errors.DecodingError "expected bigfloat value") - _ -> Left (Errors.DecodingError "expected bigfloat literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx input)))), - (Core.Name "object", (\input -> Eithers.map (\t -> Model.ValueObject t) (Helpers.decodeMap (\cx -> \raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw)) value cx input))), - (Core.Name "string", (\input -> Eithers.map (\t -> Model.ValueString t) (Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx input))))] - in (Maybes.maybe (Left (Errors.DecodingError (Strings.cat [ - "no such field ", - (Core.unName fname), - " in union"]))) (\f -> f fterm) (Maps.lookup fname variantMap)) - _ -> Left (Errors.DecodingError "expected union")) (Lexical.stripAndDereferenceTermEither cx raw) diff --git a/src/gen-main/haskell/Hydra/Decode/Module.hs b/src/gen-main/haskell/Hydra/Decode/Module.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Decode/Module.hs +++ /dev/null @@ -1,122 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Term decoders for hydra.module - -module Hydra.Decode.Module where - -import qualified Hydra.Core as Core -import qualified Hydra.Decode.Core as Core_ -import qualified Hydra.Errors as Errors -import qualified Hydra.Extract.Helpers as Helpers -import qualified Hydra.Graph as Graph -import qualified Hydra.Lexical as Lexical -import qualified Hydra.Lib.Eithers as Eithers -import qualified Hydra.Lib.Maps as Maps -import qualified Hydra.Lib.Maybes as Maybes -import qualified Hydra.Lib.Strings as Strings -import qualified Hydra.Module as Module -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -definition :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Module.Definition -definition cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermUnion v0 -> - let field = Core.injectionField v0 - fname = Core.fieldName field - fterm = Core.fieldTerm field - variantMap = - Maps.fromList [ - (Core.Name "term", (\input -> Eithers.map (\t -> Module.DefinitionTerm t) (termDefinition cx input))), - (Core.Name "type", (\input -> Eithers.map (\t -> Module.DefinitionType t) (typeDefinition cx input)))] - in (Maybes.maybe (Left (Errors.DecodingError (Strings.cat [ - "no such field ", - (Core.unName fname), - " in union"]))) (\f -> f fterm) (Maps.lookup fname variantMap)) - _ -> Left (Errors.DecodingError "expected union")) (Lexical.stripAndDereferenceTermEither cx raw) - -fileExtension :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Module.FileExtension -fileExtension cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermWrap v0 -> Eithers.map (\b -> Module.FileExtension b) ((\raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw)) (Core.wrappedTermBody v0)) - _ -> Left (Errors.DecodingError "expected wrapped type")) (Lexical.stripAndDereferenceTermEither cx raw) - -module_ :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Module.Module -module_ cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "namespace" namespace fieldMap cx) (\field_namespace -> Eithers.bind (Helpers.requireField "definitions" (Helpers.decodeList definition) fieldMap cx) (\field_definitions -> Eithers.bind (Helpers.requireField "termDependencies" (Helpers.decodeList namespace) fieldMap cx) (\field_termDependencies -> Eithers.bind (Helpers.requireField "typeDependencies" (Helpers.decodeList namespace) fieldMap cx) (\field_typeDependencies -> Eithers.bind (Helpers.requireField "description" (Helpers.decodeMaybe (\cx -> \raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw))) fieldMap cx) (\field_description -> Right (Module.Module { - Module.moduleNamespace = field_namespace, - Module.moduleDefinitions = field_definitions, - Module.moduleTermDependencies = field_termDependencies, - Module.moduleTypeDependencies = field_typeDependencies, - Module.moduleDescription = field_description}))))))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -namespace :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Module.Namespace -namespace cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermWrap v0 -> Eithers.map (\b -> Module.Namespace b) ((\raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw)) (Core.wrappedTermBody v0)) - _ -> Left (Errors.DecodingError "expected wrapped type")) (Lexical.stripAndDereferenceTermEither cx raw) - -namespaces :: (Graph.Graph -> Core.Term -> Either Errors.DecodingError t0) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (Module.Namespaces t0) -namespaces n cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "focus" (Helpers.decodePair namespace n) fieldMap cx) (\field_focus -> Eithers.bind (Helpers.requireField "mapping" (Helpers.decodeMap namespace n) fieldMap cx) (\field_mapping -> Right (Module.Namespaces { - Module.namespacesFocus = field_focus, - Module.namespacesMapping = field_mapping})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -qualifiedName :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Module.QualifiedName -qualifiedName cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "namespace" (Helpers.decodeMaybe namespace) fieldMap cx) (\field_namespace -> Eithers.bind (Helpers.requireField "local" (\cx -> \raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw)) fieldMap cx) (\field_local -> Right (Module.QualifiedName { - Module.qualifiedNameNamespace = field_namespace, - Module.qualifiedNameLocal = field_local})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -termDefinition :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Module.TermDefinition -termDefinition cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "name" Core_.name fieldMap cx) (\field_name -> Eithers.bind (Helpers.requireField "term" Core_.term fieldMap cx) (\field_term -> Eithers.bind (Helpers.requireField "type" (Helpers.decodeMaybe Core_.typeScheme) fieldMap cx) (\field_type -> Right (Module.TermDefinition { - Module.termDefinitionName = field_name, - Module.termDefinitionTerm = field_term, - Module.termDefinitionType = field_type}))))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -typeDefinition :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Module.TypeDefinition -typeDefinition cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "name" Core_.name fieldMap cx) (\field_name -> Eithers.bind (Helpers.requireField "type" Core_.type_ fieldMap cx) (\field_type -> Right (Module.TypeDefinition { - Module.typeDefinitionName = field_name, - Module.typeDefinitionType = field_type})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) diff --git a/src/gen-main/haskell/Hydra/Decode/Parsing.hs b/src/gen-main/haskell/Hydra/Decode/Parsing.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Decode/Parsing.hs +++ /dev/null @@ -1,71 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Term decoders for hydra.parsing - -module Hydra.Decode.Parsing where - -import qualified Hydra.Core as Core -import qualified Hydra.Errors as Errors -import qualified Hydra.Extract.Helpers as Helpers -import qualified Hydra.Graph as Graph -import qualified Hydra.Lexical as Lexical -import qualified Hydra.Lib.Eithers as Eithers -import qualified Hydra.Lib.Maps as Maps -import qualified Hydra.Lib.Maybes as Maybes -import qualified Hydra.Lib.Strings as Strings -import qualified Hydra.Parsing as Parsing -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -parseError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Parsing.ParseError -parseError cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "message" (\cx -> \raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw)) fieldMap cx) (\field_message -> Eithers.bind (Helpers.requireField "remainder" (\cx -> \raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw)) fieldMap cx) (\field_remainder -> Right (Parsing.ParseError { - Parsing.parseErrorMessage = field_message, - Parsing.parseErrorRemainder = field_remainder})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -parseResult :: (Graph.Graph -> Core.Term -> Either Errors.DecodingError t0) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (Parsing.ParseResult t0) -parseResult a cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermUnion v0 -> - let field = Core.injectionField v0 - fname = Core.fieldName field - fterm = Core.fieldTerm field - variantMap = - Maps.fromList [ - (Core.Name "success", (\input -> Eithers.map (\t -> Parsing.ParseResultSuccess t) (parseSuccess a cx input))), - (Core.Name "failure", (\input -> Eithers.map (\t -> Parsing.ParseResultFailure t) (parseError cx input)))] - in (Maybes.maybe (Left (Errors.DecodingError (Strings.cat [ - "no such field ", - (Core.unName fname), - " in union"]))) (\f -> f fterm) (Maps.lookup fname variantMap)) - _ -> Left (Errors.DecodingError "expected union")) (Lexical.stripAndDereferenceTermEither cx raw) - -parseSuccess :: (Graph.Graph -> Core.Term -> Either Errors.DecodingError t0) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (Parsing.ParseSuccess t0) -parseSuccess a cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "value" a fieldMap cx) (\field_value -> Eithers.bind (Helpers.requireField "remainder" (\cx -> \raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw)) fieldMap cx) (\field_remainder -> Right (Parsing.ParseSuccess { - Parsing.parseSuccessValue = field_value, - Parsing.parseSuccessRemainder = field_remainder})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) diff --git a/src/gen-main/haskell/Hydra/Decode/Paths.hs b/src/gen-main/haskell/Hydra/Decode/Paths.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Decode/Paths.hs +++ /dev/null @@ -1,213 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Term decoders for hydra.paths - -module Hydra.Decode.Paths where - -import qualified Hydra.Core as Core -import qualified Hydra.Decode.Core as Core_ -import qualified Hydra.Errors as Errors -import qualified Hydra.Extract.Helpers as Helpers -import qualified Hydra.Graph as Graph -import qualified Hydra.Lexical as Lexical -import qualified Hydra.Lib.Eithers as Eithers -import qualified Hydra.Lib.Maps as Maps -import qualified Hydra.Lib.Maybes as Maybes -import qualified Hydra.Lib.Strings as Strings -import qualified Hydra.Paths as Paths -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -subtermEdge :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Paths.SubtermEdge -subtermEdge cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "source" subtermNode fieldMap cx) (\field_source -> Eithers.bind (Helpers.requireField "path" subtermPath fieldMap cx) (\field_path -> Eithers.bind (Helpers.requireField "target" subtermNode fieldMap cx) (\field_target -> Right (Paths.SubtermEdge { - Paths.subtermEdgeSource = field_source, - Paths.subtermEdgePath = field_path, - Paths.subtermEdgeTarget = field_target}))))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -subtermGraph :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Paths.SubtermGraph -subtermGraph cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "nodes" (Helpers.decodeList subtermNode) fieldMap cx) (\field_nodes -> Eithers.bind (Helpers.requireField "edges" (Helpers.decodeList subtermEdge) fieldMap cx) (\field_edges -> Right (Paths.SubtermGraph { - Paths.subtermGraphNodes = field_nodes, - Paths.subtermGraphEdges = field_edges})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -subtermNode :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Paths.SubtermNode -subtermNode cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "name" Core_.name fieldMap cx) (\field_name -> Eithers.bind (Helpers.requireField "label" (\cx -> \raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw)) fieldMap cx) (\field_label -> Eithers.bind (Helpers.requireField "id" (\cx -> \raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw)) fieldMap cx) (\field_id -> Right (Paths.SubtermNode { - Paths.subtermNodeName = field_name, - Paths.subtermNodeLabel = field_label, - Paths.subtermNodeId = field_id}))))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -subtermPath :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Paths.SubtermPath -subtermPath cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermWrap v0 -> Eithers.map (\b -> Paths.SubtermPath b) (Helpers.decodeList subtermStep cx (Core.wrappedTermBody v0)) - _ -> Left (Errors.DecodingError "expected wrapped type")) (Lexical.stripAndDereferenceTermEither cx raw) - -subtermStep :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Paths.SubtermStep -subtermStep cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermUnion v0 -> - let field = Core.injectionField v0 - fname = Core.fieldName field - fterm = Core.fieldTerm field - variantMap = - Maps.fromList [ - (Core.Name "annotatedBody", (\input -> Eithers.map (\t -> Paths.SubtermStepAnnotatedBody) (Helpers.decodeUnit cx input))), - (Core.Name "applicationFunction", (\input -> Eithers.map (\t -> Paths.SubtermStepApplicationFunction) (Helpers.decodeUnit cx input))), - (Core.Name "applicationArgument", (\input -> Eithers.map (\t -> Paths.SubtermStepApplicationArgument) (Helpers.decodeUnit cx input))), - (Core.Name "lambdaBody", (\input -> Eithers.map (\t -> Paths.SubtermStepLambdaBody) (Helpers.decodeUnit cx input))), - (Core.Name "unionCasesDefault", (\input -> Eithers.map (\t -> Paths.SubtermStepUnionCasesDefault) (Helpers.decodeUnit cx input))), - (Core.Name "unionCasesBranch", (\input -> Eithers.map (\t -> Paths.SubtermStepUnionCasesBranch t) (Core_.name cx input))), - (Core.Name "letBody", (\input -> Eithers.map (\t -> Paths.SubtermStepLetBody) (Helpers.decodeUnit cx input))), - (Core.Name "letBinding", (\input -> Eithers.map (\t -> Paths.SubtermStepLetBinding t) (Core_.name cx input))), - (Core.Name "listElement", (\input -> Eithers.map (\t -> Paths.SubtermStepListElement t) (Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralInteger v2 -> case v2 of - Core.IntegerValueInt32 v3 -> Right v3 - _ -> Left (Errors.DecodingError "expected int32 value") - _ -> Left (Errors.DecodingError "expected int32 literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx input)))), - (Core.Name "mapKey", (\input -> Eithers.map (\t -> Paths.SubtermStepMapKey t) (Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralInteger v2 -> case v2 of - Core.IntegerValueInt32 v3 -> Right v3 - _ -> Left (Errors.DecodingError "expected int32 value") - _ -> Left (Errors.DecodingError "expected int32 literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx input)))), - (Core.Name "mapValue", (\input -> Eithers.map (\t -> Paths.SubtermStepMapValue t) (Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralInteger v2 -> case v2 of - Core.IntegerValueInt32 v3 -> Right v3 - _ -> Left (Errors.DecodingError "expected int32 value") - _ -> Left (Errors.DecodingError "expected int32 literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx input)))), - (Core.Name "maybeTerm", (\input -> Eithers.map (\t -> Paths.SubtermStepMaybeTerm) (Helpers.decodeUnit cx input))), - (Core.Name "productTerm", (\input -> Eithers.map (\t -> Paths.SubtermStepProductTerm t) (Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralInteger v2 -> case v2 of - Core.IntegerValueInt32 v3 -> Right v3 - _ -> Left (Errors.DecodingError "expected int32 value") - _ -> Left (Errors.DecodingError "expected int32 literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx input)))), - (Core.Name "recordField", (\input -> Eithers.map (\t -> Paths.SubtermStepRecordField t) (Core_.name cx input))), - (Core.Name "setElement", (\input -> Eithers.map (\t -> Paths.SubtermStepSetElement t) (Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralInteger v2 -> case v2 of - Core.IntegerValueInt32 v3 -> Right v3 - _ -> Left (Errors.DecodingError "expected int32 value") - _ -> Left (Errors.DecodingError "expected int32 literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx input)))), - (Core.Name "sumTerm", (\input -> Eithers.map (\t -> Paths.SubtermStepSumTerm) (Helpers.decodeUnit cx input))), - (Core.Name "typeLambdaBody", (\input -> Eithers.map (\t -> Paths.SubtermStepTypeLambdaBody) (Helpers.decodeUnit cx input))), - (Core.Name "typeApplicationTerm", (\input -> Eithers.map (\t -> Paths.SubtermStepTypeApplicationTerm) (Helpers.decodeUnit cx input))), - (Core.Name "injectionTerm", (\input -> Eithers.map (\t -> Paths.SubtermStepInjectionTerm) (Helpers.decodeUnit cx input))), - (Core.Name "wrappedTerm", (\input -> Eithers.map (\t -> Paths.SubtermStepWrappedTerm) (Helpers.decodeUnit cx input)))] - in (Maybes.maybe (Left (Errors.DecodingError (Strings.cat [ - "no such field ", - (Core.unName fname), - " in union"]))) (\f -> f fterm) (Maps.lookup fname variantMap)) - _ -> Left (Errors.DecodingError "expected union")) (Lexical.stripAndDereferenceTermEither cx raw) - -subtypeEdge :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Paths.SubtypeEdge -subtypeEdge cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "source" subtypeNode fieldMap cx) (\field_source -> Eithers.bind (Helpers.requireField "path" subtypePath fieldMap cx) (\field_path -> Eithers.bind (Helpers.requireField "target" subtypeNode fieldMap cx) (\field_target -> Right (Paths.SubtypeEdge { - Paths.subtypeEdgeSource = field_source, - Paths.subtypeEdgePath = field_path, - Paths.subtypeEdgeTarget = field_target}))))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -subtypeGraph :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Paths.SubtypeGraph -subtypeGraph cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "nodes" (Helpers.decodeList subtypeNode) fieldMap cx) (\field_nodes -> Eithers.bind (Helpers.requireField "edges" (Helpers.decodeList subtypeEdge) fieldMap cx) (\field_edges -> Right (Paths.SubtypeGraph { - Paths.subtypeGraphNodes = field_nodes, - Paths.subtypeGraphEdges = field_edges})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -subtypeNode :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Paths.SubtypeNode -subtypeNode cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "name" Core_.name fieldMap cx) (\field_name -> Eithers.bind (Helpers.requireField "label" (\cx -> \raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw)) fieldMap cx) (\field_label -> Eithers.bind (Helpers.requireField "id" (\cx -> \raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw)) fieldMap cx) (\field_id -> Right (Paths.SubtypeNode { - Paths.subtypeNodeName = field_name, - Paths.subtypeNodeLabel = field_label, - Paths.subtypeNodeId = field_id}))))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -subtypePath :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Paths.SubtypePath -subtypePath cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermWrap v0 -> Eithers.map (\b -> Paths.SubtypePath b) (Helpers.decodeList subtypeStep cx (Core.wrappedTermBody v0)) - _ -> Left (Errors.DecodingError "expected wrapped type")) (Lexical.stripAndDereferenceTermEither cx raw) - -subtypeStep :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Paths.SubtypeStep -subtypeStep cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermUnion v0 -> - let field = Core.injectionField v0 - fname = Core.fieldName field - fterm = Core.fieldTerm field - variantMap = - Maps.fromList [ - (Core.Name "annotatedBody", (\input -> Eithers.map (\t -> Paths.SubtypeStepAnnotatedBody) (Helpers.decodeUnit cx input))), - (Core.Name "applicationFunction", (\input -> Eithers.map (\t -> Paths.SubtypeStepApplicationFunction) (Helpers.decodeUnit cx input))), - (Core.Name "applicationArgument", (\input -> Eithers.map (\t -> Paths.SubtypeStepApplicationArgument) (Helpers.decodeUnit cx input))), - (Core.Name "eitherLeft", (\input -> Eithers.map (\t -> Paths.SubtypeStepEitherLeft) (Helpers.decodeUnit cx input))), - (Core.Name "eitherRight", (\input -> Eithers.map (\t -> Paths.SubtypeStepEitherRight) (Helpers.decodeUnit cx input))), - (Core.Name "forallBody", (\input -> Eithers.map (\t -> Paths.SubtypeStepForallBody) (Helpers.decodeUnit cx input))), - (Core.Name "functionDomain", (\input -> Eithers.map (\t -> Paths.SubtypeStepFunctionDomain) (Helpers.decodeUnit cx input))), - (Core.Name "functionCodomain", (\input -> Eithers.map (\t -> Paths.SubtypeStepFunctionCodomain) (Helpers.decodeUnit cx input))), - (Core.Name "listElement", (\input -> Eithers.map (\t -> Paths.SubtypeStepListElement) (Helpers.decodeUnit cx input))), - (Core.Name "mapKeys", (\input -> Eithers.map (\t -> Paths.SubtypeStepMapKeys) (Helpers.decodeUnit cx input))), - (Core.Name "mapValues", (\input -> Eithers.map (\t -> Paths.SubtypeStepMapValues) (Helpers.decodeUnit cx input))), - (Core.Name "maybeElement", (\input -> Eithers.map (\t -> Paths.SubtypeStepMaybeElement) (Helpers.decodeUnit cx input))), - (Core.Name "pairFirst", (\input -> Eithers.map (\t -> Paths.SubtypeStepPairFirst) (Helpers.decodeUnit cx input))), - (Core.Name "pairSecond", (\input -> Eithers.map (\t -> Paths.SubtypeStepPairSecond) (Helpers.decodeUnit cx input))), - (Core.Name "recordField", (\input -> Eithers.map (\t -> Paths.SubtypeStepRecordField t) (Core_.name cx input))), - (Core.Name "setElement", (\input -> Eithers.map (\t -> Paths.SubtypeStepSetElement) (Helpers.decodeUnit cx input))), - (Core.Name "unionField", (\input -> Eithers.map (\t -> Paths.SubtypeStepUnionField t) (Core_.name cx input))), - (Core.Name "wrappedType", (\input -> Eithers.map (\t -> Paths.SubtypeStepWrappedType) (Helpers.decodeUnit cx input)))] - in (Maybes.maybe (Left (Errors.DecodingError (Strings.cat [ - "no such field ", - (Core.unName fname), - " in union"]))) (\f -> f fterm) (Maps.lookup fname variantMap)) - _ -> Left (Errors.DecodingError "expected union")) (Lexical.stripAndDereferenceTermEither cx raw) diff --git a/src/gen-main/haskell/Hydra/Decode/Phantoms.hs b/src/gen-main/haskell/Hydra/Decode/Phantoms.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Decode/Phantoms.hs +++ /dev/null @@ -1,36 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Term decoders for hydra.phantoms - -module Hydra.Decode.Phantoms where - -import qualified Hydra.Core as Core -import qualified Hydra.Decode.Core as Core_ -import qualified Hydra.Errors as Errors -import qualified Hydra.Extract.Helpers as Helpers -import qualified Hydra.Graph as Graph -import qualified Hydra.Lexical as Lexical -import qualified Hydra.Lib.Eithers as Eithers -import qualified Hydra.Phantoms as Phantoms -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -tBinding :: t0 -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (Phantoms.TBinding t1) -tBinding a cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "name" Core_.name fieldMap cx) (\field_name -> Eithers.bind (Helpers.requireField "term" (tTerm a) fieldMap cx) (\field_term -> Right (Phantoms.TBinding { - Phantoms.tBindingName = field_name, - Phantoms.tBindingTerm = field_term})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -tTerm :: t0 -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (Phantoms.TTerm t1) -tTerm a cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermWrap v0 -> Eithers.map (\b -> Phantoms.TTerm b) (Core_.term cx (Core.wrappedTermBody v0)) - _ -> Left (Errors.DecodingError "expected wrapped type")) (Lexical.stripAndDereferenceTermEither cx raw) diff --git a/src/gen-main/haskell/Hydra/Decode/Query.hs b/src/gen-main/haskell/Hydra/Decode/Query.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Decode/Query.hs +++ /dev/null @@ -1,256 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Term decoders for hydra.query - -module Hydra.Decode.Query where - -import qualified Hydra.Core as Core -import qualified Hydra.Decode.Core as Core_ -import qualified Hydra.Errors as Errors -import qualified Hydra.Extract.Helpers as Helpers -import qualified Hydra.Graph as Graph -import qualified Hydra.Lexical as Lexical -import qualified Hydra.Lib.Eithers as Eithers -import qualified Hydra.Lib.Maps as Maps -import qualified Hydra.Lib.Maybes as Maybes -import qualified Hydra.Lib.Strings as Strings -import qualified Hydra.Query as Query -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -comparisonConstraint :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Query.ComparisonConstraint -comparisonConstraint cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermUnion v0 -> - let field = Core.injectionField v0 - fname = Core.fieldName field - fterm = Core.fieldTerm field - variantMap = - Maps.fromList [ - (Core.Name "equal", (\input -> Eithers.map (\t -> Query.ComparisonConstraintEqual) (Helpers.decodeUnit cx input))), - (Core.Name "notEqual", (\input -> Eithers.map (\t -> Query.ComparisonConstraintNotEqual) (Helpers.decodeUnit cx input))), - (Core.Name "lessThan", (\input -> Eithers.map (\t -> Query.ComparisonConstraintLessThan) (Helpers.decodeUnit cx input))), - (Core.Name "greaterThan", (\input -> Eithers.map (\t -> Query.ComparisonConstraintGreaterThan) (Helpers.decodeUnit cx input))), - (Core.Name "lessThanOrEqual", (\input -> Eithers.map (\t -> Query.ComparisonConstraintLessThanOrEqual) (Helpers.decodeUnit cx input))), - (Core.Name "greaterThanOrEqual", (\input -> Eithers.map (\t -> Query.ComparisonConstraintGreaterThanOrEqual) (Helpers.decodeUnit cx input)))] - in (Maybes.maybe (Left (Errors.DecodingError (Strings.cat [ - "no such field ", - (Core.unName fname), - " in union"]))) (\f -> f fterm) (Maps.lookup fname variantMap)) - _ -> Left (Errors.DecodingError "expected union")) (Lexical.stripAndDereferenceTermEither cx raw) - -edge :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Query.Edge -edge cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "type" Core_.name fieldMap cx) (\field_type -> Eithers.bind (Helpers.requireField "out" (Helpers.decodeMaybe Core_.name) fieldMap cx) (\field_out -> Eithers.bind (Helpers.requireField "in" (Helpers.decodeMaybe Core_.name) fieldMap cx) (\field_in -> Right (Query.Edge { - Query.edgeType = field_type, - Query.edgeOut = field_out, - Query.edgeIn = field_in}))))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -graphPattern :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Query.GraphPattern -graphPattern cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "graph" Core_.name fieldMap cx) (\field_graph -> Eithers.bind (Helpers.requireField "patterns" (Helpers.decodeList pattern) fieldMap cx) (\field_patterns -> Right (Query.GraphPattern { - Query.graphPatternGraph = field_graph, - Query.graphPatternPatterns = field_patterns})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -node :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Query.Node -node cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermUnion v0 -> - let field = Core.injectionField v0 - fname = Core.fieldName field - fterm = Core.fieldTerm field - variantMap = - Maps.fromList [ - (Core.Name "term", (\input -> Eithers.map (\t -> Query.NodeTerm t) (Core_.term cx input))), - (Core.Name "variable", (\input -> Eithers.map (\t -> Query.NodeVariable t) (variable cx input))), - (Core.Name "wildcard", (\input -> Eithers.map (\t -> Query.NodeWildcard) (Helpers.decodeUnit cx input)))] - in (Maybes.maybe (Left (Errors.DecodingError (Strings.cat [ - "no such field ", - (Core.unName fname), - " in union"]))) (\f -> f fterm) (Maps.lookup fname variantMap)) - _ -> Left (Errors.DecodingError "expected union")) (Lexical.stripAndDereferenceTermEither cx raw) - -path :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Query.Path -path cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermUnion v0 -> - let field = Core.injectionField v0 - fname = Core.fieldName field - fterm = Core.fieldTerm field - variantMap = - Maps.fromList [ - (Core.Name "step", (\input -> Eithers.map (\t -> Query.PathStep t) (step cx input))), - (Core.Name "regex", (\input -> Eithers.map (\t -> Query.PathRegex t) (regexSequence cx input))), - (Core.Name "inverse", (\input -> Eithers.map (\t -> Query.PathInverse t) (path cx input)))] - in (Maybes.maybe (Left (Errors.DecodingError (Strings.cat [ - "no such field ", - (Core.unName fname), - " in union"]))) (\f -> f fterm) (Maps.lookup fname variantMap)) - _ -> Left (Errors.DecodingError "expected union")) (Lexical.stripAndDereferenceTermEither cx raw) - -pathEquation :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Query.PathEquation -pathEquation cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "left" path fieldMap cx) (\field_left -> Eithers.bind (Helpers.requireField "right" path fieldMap cx) (\field_right -> Right (Query.PathEquation { - Query.pathEquationLeft = field_left, - Query.pathEquationRight = field_right})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -pattern :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Query.Pattern -pattern cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermUnion v0 -> - let field = Core.injectionField v0 - fname = Core.fieldName field - fterm = Core.fieldTerm field - variantMap = - Maps.fromList [ - (Core.Name "triple", (\input -> Eithers.map (\t -> Query.PatternTriple t) (triplePattern cx input))), - (Core.Name "negation", (\input -> Eithers.map (\t -> Query.PatternNegation t) (pattern cx input))), - (Core.Name "conjunction", (\input -> Eithers.map (\t -> Query.PatternConjunction t) (Helpers.decodeList pattern cx input))), - (Core.Name "disjunction", (\input -> Eithers.map (\t -> Query.PatternDisjunction t) (Helpers.decodeList pattern cx input))), - (Core.Name "graph", (\input -> Eithers.map (\t -> Query.PatternGraph t) (graphPattern cx input)))] - in (Maybes.maybe (Left (Errors.DecodingError (Strings.cat [ - "no such field ", - (Core.unName fname), - " in union"]))) (\f -> f fterm) (Maps.lookup fname variantMap)) - _ -> Left (Errors.DecodingError "expected union")) (Lexical.stripAndDereferenceTermEither cx raw) - -patternImplication :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Query.PatternImplication -patternImplication cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "antecedent" pattern fieldMap cx) (\field_antecedent -> Eithers.bind (Helpers.requireField "consequent" pattern fieldMap cx) (\field_consequent -> Right (Query.PatternImplication { - Query.patternImplicationAntecedent = field_antecedent, - Query.patternImplicationConsequent = field_consequent})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -query :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Query.Query -query cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "variables" (Helpers.decodeList variable) fieldMap cx) (\field_variables -> Eithers.bind (Helpers.requireField "patterns" (Helpers.decodeList pattern) fieldMap cx) (\field_patterns -> Right (Query.Query { - Query.queryVariables = field_variables, - Query.queryPatterns = field_patterns})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -range :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Query.Range -range cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "min" (\cx -> \raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralInteger v2 -> case v2 of - Core.IntegerValueInt32 v3 -> Right v3 - _ -> Left (Errors.DecodingError "expected int32 value") - _ -> Left (Errors.DecodingError "expected int32 literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw)) fieldMap cx) (\field_min -> Eithers.bind (Helpers.requireField "max" (\cx -> \raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralInteger v2 -> case v2 of - Core.IntegerValueInt32 v3 -> Right v3 - _ -> Left (Errors.DecodingError "expected int32 value") - _ -> Left (Errors.DecodingError "expected int32 literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw)) fieldMap cx) (\field_max -> Right (Query.Range { - Query.rangeMin = field_min, - Query.rangeMax = field_max})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -regexQuantifier :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Query.RegexQuantifier -regexQuantifier cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermUnion v0 -> - let field = Core.injectionField v0 - fname = Core.fieldName field - fterm = Core.fieldTerm field - variantMap = - Maps.fromList [ - (Core.Name "one", (\input -> Eithers.map (\t -> Query.RegexQuantifierOne) (Helpers.decodeUnit cx input))), - (Core.Name "zeroOrOne", (\input -> Eithers.map (\t -> Query.RegexQuantifierZeroOrOne) (Helpers.decodeUnit cx input))), - (Core.Name "zeroOrMore", (\input -> Eithers.map (\t -> Query.RegexQuantifierZeroOrMore) (Helpers.decodeUnit cx input))), - (Core.Name "oneOrMore", (\input -> Eithers.map (\t -> Query.RegexQuantifierOneOrMore) (Helpers.decodeUnit cx input))), - (Core.Name "exactly", (\input -> Eithers.map (\t -> Query.RegexQuantifierExactly t) (Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralInteger v2 -> case v2 of - Core.IntegerValueInt32 v3 -> Right v3 - _ -> Left (Errors.DecodingError "expected int32 value") - _ -> Left (Errors.DecodingError "expected int32 literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx input)))), - (Core.Name "atLeast", (\input -> Eithers.map (\t -> Query.RegexQuantifierAtLeast t) (Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralInteger v2 -> case v2 of - Core.IntegerValueInt32 v3 -> Right v3 - _ -> Left (Errors.DecodingError "expected int32 value") - _ -> Left (Errors.DecodingError "expected int32 literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx input)))), - (Core.Name "range", (\input -> Eithers.map (\t -> Query.RegexQuantifierRange t) (range cx input)))] - in (Maybes.maybe (Left (Errors.DecodingError (Strings.cat [ - "no such field ", - (Core.unName fname), - " in union"]))) (\f -> f fterm) (Maps.lookup fname variantMap)) - _ -> Left (Errors.DecodingError "expected union")) (Lexical.stripAndDereferenceTermEither cx raw) - -regexSequence :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Query.RegexSequence -regexSequence cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "path" path fieldMap cx) (\field_path -> Eithers.bind (Helpers.requireField "quantifier" regexQuantifier fieldMap cx) (\field_quantifier -> Right (Query.RegexSequence { - Query.regexSequencePath = field_path, - Query.regexSequenceQuantifier = field_quantifier})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -step :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Query.Step -step cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermUnion v0 -> - let field = Core.injectionField v0 - fname = Core.fieldName field - fterm = Core.fieldTerm field - variantMap = - Maps.fromList [ - (Core.Name "edge", (\input -> Eithers.map (\t -> Query.StepEdge t) (edge cx input))), - (Core.Name "project", (\input -> Eithers.map (\t -> Query.StepProject t) (Core_.projection cx input))), - (Core.Name "compare", (\input -> Eithers.map (\t -> Query.StepCompare t) (comparisonConstraint cx input)))] - in (Maybes.maybe (Left (Errors.DecodingError (Strings.cat [ - "no such field ", - (Core.unName fname), - " in union"]))) (\f -> f fterm) (Maps.lookup fname variantMap)) - _ -> Left (Errors.DecodingError "expected union")) (Lexical.stripAndDereferenceTermEither cx raw) - -triplePattern :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Query.TriplePattern -triplePattern cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "subject" node fieldMap cx) (\field_subject -> Eithers.bind (Helpers.requireField "predicate" path fieldMap cx) (\field_predicate -> Eithers.bind (Helpers.requireField "object" node fieldMap cx) (\field_object -> Right (Query.TriplePattern { - Query.triplePatternSubject = field_subject, - Query.triplePatternPredicate = field_predicate, - Query.triplePatternObject = field_object}))))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -variable :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Query.Variable -variable cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermWrap v0 -> Eithers.map (\b -> Query.Variable b) ((\raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw)) (Core.wrappedTermBody v0)) - _ -> Left (Errors.DecodingError "expected wrapped type")) (Lexical.stripAndDereferenceTermEither cx raw) diff --git a/src/gen-main/haskell/Hydra/Decode/Relational.hs b/src/gen-main/haskell/Hydra/Decode/Relational.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Decode/Relational.hs +++ /dev/null @@ -1,95 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Term decoders for hydra.relational - -module Hydra.Decode.Relational where - -import qualified Hydra.Core as Core -import qualified Hydra.Errors as Errors -import qualified Hydra.Extract.Helpers as Helpers -import qualified Hydra.Graph as Graph -import qualified Hydra.Lexical as Lexical -import qualified Hydra.Lib.Eithers as Eithers -import qualified Hydra.Relational as Relational -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -columnName :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Relational.ColumnName -columnName cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermWrap v0 -> Eithers.map (\b -> Relational.ColumnName b) ((\raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw)) (Core.wrappedTermBody v0)) - _ -> Left (Errors.DecodingError "expected wrapped type")) (Lexical.stripAndDereferenceTermEither cx raw) - -columnSchema :: (Graph.Graph -> Core.Term -> Either Errors.DecodingError t0) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (Relational.ColumnSchema t0) -columnSchema t cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "name" columnName fieldMap cx) (\field_name -> Eithers.bind (Helpers.requireField "domain" t fieldMap cx) (\field_domain -> Right (Relational.ColumnSchema { - Relational.columnSchemaName = field_name, - Relational.columnSchemaDomain = field_domain})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -foreignKey :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Relational.ForeignKey -foreignKey cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "foreignRelation" relationName fieldMap cx) (\field_foreignRelation -> Eithers.bind (Helpers.requireField "keys" (Helpers.decodeMap columnName columnName) fieldMap cx) (\field_keys -> Right (Relational.ForeignKey { - Relational.foreignKeyForeignRelation = field_foreignRelation, - Relational.foreignKeyKeys = field_keys})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -primaryKey :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Relational.PrimaryKey -primaryKey cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermWrap v0 -> Eithers.map (\b -> Relational.PrimaryKey b) (Helpers.decodeList columnName cx (Core.wrappedTermBody v0)) - _ -> Left (Errors.DecodingError "expected wrapped type")) (Lexical.stripAndDereferenceTermEither cx raw) - -relation :: (Graph.Graph -> Core.Term -> Either Errors.DecodingError t0) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (Relational.Relation t0) -relation v cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermWrap v0 -> Eithers.map (\b -> Relational.Relation b) (Helpers.decodeList (row v) cx (Core.wrappedTermBody v0)) - _ -> Left (Errors.DecodingError "expected wrapped type")) (Lexical.stripAndDereferenceTermEither cx raw) - -relationName :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Relational.RelationName -relationName cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermWrap v0 -> Eithers.map (\b -> Relational.RelationName b) ((\raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw)) (Core.wrappedTermBody v0)) - _ -> Left (Errors.DecodingError "expected wrapped type")) (Lexical.stripAndDereferenceTermEither cx raw) - -relationSchema :: (Graph.Graph -> Core.Term -> Either Errors.DecodingError t0) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (Relational.RelationSchema t0) -relationSchema t cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "name" relationName fieldMap cx) (\field_name -> Eithers.bind (Helpers.requireField "columns" (Helpers.decodeList (columnSchema t)) fieldMap cx) (\field_columns -> Eithers.bind (Helpers.requireField "primaryKeys" (Helpers.decodeList primaryKey) fieldMap cx) (\field_primaryKeys -> Eithers.bind (Helpers.requireField "foreignKeys" (Helpers.decodeList foreignKey) fieldMap cx) (\field_foreignKeys -> Right (Relational.RelationSchema { - Relational.relationSchemaName = field_name, - Relational.relationSchemaColumns = field_columns, - Relational.relationSchemaPrimaryKeys = field_primaryKeys, - Relational.relationSchemaForeignKeys = field_foreignKeys})))))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -relationship :: Ord t0 => ((Graph.Graph -> Core.Term -> Either Errors.DecodingError t0) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (Relational.Relationship t0)) -relationship v cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermWrap v0 -> Eithers.map (\b -> Relational.Relationship b) (Helpers.decodeSet (Helpers.decodeMap columnName v) cx (Core.wrappedTermBody v0)) - _ -> Left (Errors.DecodingError "expected wrapped type")) (Lexical.stripAndDereferenceTermEither cx raw) - -row :: (Graph.Graph -> Core.Term -> Either Errors.DecodingError t0) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (Relational.Row t0) -row v cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermWrap v0 -> Eithers.map (\b -> Relational.Row b) (Helpers.decodeList v cx (Core.wrappedTermBody v0)) - _ -> Left (Errors.DecodingError "expected wrapped type")) (Lexical.stripAndDereferenceTermEither cx raw) diff --git a/src/gen-main/haskell/Hydra/Decode/Tabular.hs b/src/gen-main/haskell/Hydra/Decode/Tabular.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Decode/Tabular.hs +++ /dev/null @@ -1,67 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Term decoders for hydra.tabular - -module Hydra.Decode.Tabular where - -import qualified Hydra.Core as Core -import qualified Hydra.Decode.Core as Core_ -import qualified Hydra.Decode.Relational as Relational -import qualified Hydra.Errors as Errors -import qualified Hydra.Extract.Helpers as Helpers -import qualified Hydra.Graph as Graph -import qualified Hydra.Lexical as Lexical -import qualified Hydra.Lib.Eithers as Eithers -import qualified Hydra.Tabular as Tabular -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -columnType :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Tabular.ColumnType -columnType cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "name" Relational.columnName fieldMap cx) (\field_name -> Eithers.bind (Helpers.requireField "type" Core_.type_ fieldMap cx) (\field_type -> Right (Tabular.ColumnType { - Tabular.columnTypeName = field_name, - Tabular.columnTypeType = field_type})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -dataRow :: (Graph.Graph -> Core.Term -> Either Errors.DecodingError t0) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (Tabular.DataRow t0) -dataRow v cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermWrap v0 -> Eithers.map (\b -> Tabular.DataRow b) (Helpers.decodeList (Helpers.decodeMaybe v) cx (Core.wrappedTermBody v0)) - _ -> Left (Errors.DecodingError "expected wrapped type")) (Lexical.stripAndDereferenceTermEither cx raw) - -headerRow :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Tabular.HeaderRow -headerRow cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermWrap v0 -> Eithers.map (\b -> Tabular.HeaderRow b) (Helpers.decodeList (\cx -> \raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw)) cx (Core.wrappedTermBody v0)) - _ -> Left (Errors.DecodingError "expected wrapped type")) (Lexical.stripAndDereferenceTermEither cx raw) - -table :: (Graph.Graph -> Core.Term -> Either Errors.DecodingError t0) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (Tabular.Table t0) -table v cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "header" (Helpers.decodeMaybe headerRow) fieldMap cx) (\field_header -> Eithers.bind (Helpers.requireField "data" (Helpers.decodeList (dataRow v)) fieldMap cx) (\field_data -> Right (Tabular.Table { - Tabular.tableHeader = field_header, - Tabular.tableData = field_data})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -tableType :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Tabular.TableType -tableType cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "name" Relational.relationName fieldMap cx) (\field_name -> Eithers.bind (Helpers.requireField "columns" (Helpers.decodeList columnType) fieldMap cx) (\field_columns -> Right (Tabular.TableType { - Tabular.tableTypeName = field_name, - Tabular.tableTypeColumns = field_columns})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) diff --git a/src/gen-main/haskell/Hydra/Decode/Testing.hs b/src/gen-main/haskell/Hydra/Decode/Testing.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Decode/Testing.hs +++ /dev/null @@ -1,716 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Term decoders for hydra.testing - -module Hydra.Decode.Testing where - -import qualified Hydra.Core as Core -import qualified Hydra.Decode.Ast as Ast -import qualified Hydra.Decode.Coders as Coders -import qualified Hydra.Decode.Core as Core_ -import qualified Hydra.Decode.Error.Core as Core__ -import qualified Hydra.Decode.Json.Model as Model -import qualified Hydra.Decode.Parsing as Parsing -import qualified Hydra.Decode.Typing as Typing -import qualified Hydra.Decode.Util as Util -import qualified Hydra.Errors as Errors -import qualified Hydra.Extract.Helpers as Helpers -import qualified Hydra.Graph as Graph -import qualified Hydra.Json.Model as Model_ -import qualified Hydra.Lexical as Lexical -import qualified Hydra.Lib.Eithers as Eithers -import qualified Hydra.Lib.Maps as Maps -import qualified Hydra.Lib.Maybes as Maybes -import qualified Hydra.Lib.Strings as Strings -import qualified Hydra.Testing as Testing -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -alphaConversionTestCase :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Testing.AlphaConversionTestCase -alphaConversionTestCase cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "term" Core_.term fieldMap cx) (\field_term -> Eithers.bind (Helpers.requireField "oldVariable" Core_.name fieldMap cx) (\field_oldVariable -> Eithers.bind (Helpers.requireField "newVariable" Core_.name fieldMap cx) (\field_newVariable -> Eithers.bind (Helpers.requireField "result" Core_.term fieldMap cx) (\field_result -> Right (Testing.AlphaConversionTestCase { - Testing.alphaConversionTestCaseTerm = field_term, - Testing.alphaConversionTestCaseOldVariable = field_oldVariable, - Testing.alphaConversionTestCaseNewVariable = field_newVariable, - Testing.alphaConversionTestCaseResult = field_result})))))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -caseConversionTestCase :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Testing.CaseConversionTestCase -caseConversionTestCase cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "fromConvention" Util.caseConvention fieldMap cx) (\field_fromConvention -> Eithers.bind (Helpers.requireField "toConvention" Util.caseConvention fieldMap cx) (\field_toConvention -> Eithers.bind (Helpers.requireField "fromString" (\cx -> \raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw)) fieldMap cx) (\field_fromString -> Eithers.bind (Helpers.requireField "toString" (\cx -> \raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw)) fieldMap cx) (\field_toString -> Right (Testing.CaseConversionTestCase { - Testing.caseConversionTestCaseFromConvention = field_fromConvention, - Testing.caseConversionTestCaseToConvention = field_toConvention, - Testing.caseConversionTestCaseFromString = field_fromString, - Testing.caseConversionTestCaseToString = field_toString})))))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -deannotateTermTestCase :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Testing.DeannotateTermTestCase -deannotateTermTestCase cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "input" Core_.term fieldMap cx) (\field_input -> Eithers.bind (Helpers.requireField "output" Core_.term fieldMap cx) (\field_output -> Right (Testing.DeannotateTermTestCase { - Testing.deannotateTermTestCaseInput = field_input, - Testing.deannotateTermTestCaseOutput = field_output})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -deannotateTypeTestCase :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Testing.DeannotateTypeTestCase -deannotateTypeTestCase cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "input" Core_.type_ fieldMap cx) (\field_input -> Eithers.bind (Helpers.requireField "output" Core_.type_ fieldMap cx) (\field_output -> Right (Testing.DeannotateTypeTestCase { - Testing.deannotateTypeTestCaseInput = field_input, - Testing.deannotateTypeTestCaseOutput = field_output})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -delegatedEvaluationTestCase :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Testing.DelegatedEvaluationTestCase -delegatedEvaluationTestCase cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "input" Core_.term fieldMap cx) (\field_input -> Eithers.bind (Helpers.requireField "output" Core_.term fieldMap cx) (\field_output -> Right (Testing.DelegatedEvaluationTestCase { - Testing.delegatedEvaluationTestCaseInput = field_input, - Testing.delegatedEvaluationTestCaseOutput = field_output})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -etaExpansionTestCase :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Testing.EtaExpansionTestCase -etaExpansionTestCase cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "input" Core_.term fieldMap cx) (\field_input -> Eithers.bind (Helpers.requireField "output" Core_.term fieldMap cx) (\field_output -> Right (Testing.EtaExpansionTestCase { - Testing.etaExpansionTestCaseInput = field_input, - Testing.etaExpansionTestCaseOutput = field_output})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -evaluationStyle :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Testing.EvaluationStyle -evaluationStyle cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermUnion v0 -> - let field = Core.injectionField v0 - fname = Core.fieldName field - fterm = Core.fieldTerm field - variantMap = - Maps.fromList [ - (Core.Name "eager", (\input -> Eithers.map (\t -> Testing.EvaluationStyleEager) (Helpers.decodeUnit cx input))), - (Core.Name "lazy", (\input -> Eithers.map (\t -> Testing.EvaluationStyleLazy) (Helpers.decodeUnit cx input)))] - in (Maybes.maybe (Left (Errors.DecodingError (Strings.cat [ - "no such field ", - (Core.unName fname), - " in union"]))) (\f -> f fterm) (Maps.lookup fname variantMap)) - _ -> Left (Errors.DecodingError "expected union")) (Lexical.stripAndDereferenceTermEither cx raw) - -evaluationTestCase :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Testing.EvaluationTestCase -evaluationTestCase cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "evaluationStyle" evaluationStyle fieldMap cx) (\field_evaluationStyle -> Eithers.bind (Helpers.requireField "input" Core_.term fieldMap cx) (\field_input -> Eithers.bind (Helpers.requireField "output" Core_.term fieldMap cx) (\field_output -> Right (Testing.EvaluationTestCase { - Testing.evaluationTestCaseEvaluationStyle = field_evaluationStyle, - Testing.evaluationTestCaseInput = field_input, - Testing.evaluationTestCaseOutput = field_output}))))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -flattenLetTermsTestCase :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Testing.FlattenLetTermsTestCase -flattenLetTermsTestCase cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "input" Core_.term fieldMap cx) (\field_input -> Eithers.bind (Helpers.requireField "output" Core_.term fieldMap cx) (\field_output -> Right (Testing.FlattenLetTermsTestCase { - Testing.flattenLetTermsTestCaseInput = field_input, - Testing.flattenLetTermsTestCaseOutput = field_output})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -foldOperation :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Testing.FoldOperation -foldOperation cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermUnion v0 -> - let field = Core.injectionField v0 - fname = Core.fieldName field - fterm = Core.fieldTerm field - variantMap = - Maps.fromList [ - (Core.Name "sumInt32Literals", (\input -> Eithers.map (\t -> Testing.FoldOperationSumInt32Literals) (Helpers.decodeUnit cx input))), - (Core.Name "collectListLengths", (\input -> Eithers.map (\t -> Testing.FoldOperationCollectListLengths) (Helpers.decodeUnit cx input))), - (Core.Name "collectLabels", (\input -> Eithers.map (\t -> Testing.FoldOperationCollectLabels) (Helpers.decodeUnit cx input)))] - in (Maybes.maybe (Left (Errors.DecodingError (Strings.cat [ - "no such field ", - (Core.unName fname), - " in union"]))) (\f -> f fterm) (Maps.lookup fname variantMap)) - _ -> Left (Errors.DecodingError "expected union")) (Lexical.stripAndDereferenceTermEither cx raw) - -foldOverTermTestCase :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Testing.FoldOverTermTestCase -foldOverTermTestCase cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "input" Core_.term fieldMap cx) (\field_input -> Eithers.bind (Helpers.requireField "traversalOrder" Coders.traversalOrder fieldMap cx) (\field_traversalOrder -> Eithers.bind (Helpers.requireField "operation" foldOperation fieldMap cx) (\field_operation -> Eithers.bind (Helpers.requireField "output" Core_.term fieldMap cx) (\field_output -> Right (Testing.FoldOverTermTestCase { - Testing.foldOverTermTestCaseInput = field_input, - Testing.foldOverTermTestCaseTraversalOrder = field_traversalOrder, - Testing.foldOverTermTestCaseOperation = field_operation, - Testing.foldOverTermTestCaseOutput = field_output})))))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -freeVariablesTestCase :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Testing.FreeVariablesTestCase -freeVariablesTestCase cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "input" Core_.term fieldMap cx) (\field_input -> Eithers.bind (Helpers.requireField "output" (Helpers.decodeSet Core_.name) fieldMap cx) (\field_output -> Right (Testing.FreeVariablesTestCase { - Testing.freeVariablesTestCaseInput = field_input, - Testing.freeVariablesTestCaseOutput = field_output})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -hoistCaseStatementsTestCase :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Testing.HoistCaseStatementsTestCase -hoistCaseStatementsTestCase cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "input" Core_.term fieldMap cx) (\field_input -> Eithers.bind (Helpers.requireField "output" Core_.term fieldMap cx) (\field_output -> Right (Testing.HoistCaseStatementsTestCase { - Testing.hoistCaseStatementsTestCaseInput = field_input, - Testing.hoistCaseStatementsTestCaseOutput = field_output})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -hoistLetBindingsTestCase :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Testing.HoistLetBindingsTestCase -hoistLetBindingsTestCase cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "input" Core_.let_ fieldMap cx) (\field_input -> Eithers.bind (Helpers.requireField "output" Core_.let_ fieldMap cx) (\field_output -> Right (Testing.HoistLetBindingsTestCase { - Testing.hoistLetBindingsTestCaseInput = field_input, - Testing.hoistLetBindingsTestCaseOutput = field_output})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -hoistPolymorphicLetBindingsTestCase :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Testing.HoistPolymorphicLetBindingsTestCase -hoistPolymorphicLetBindingsTestCase cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "input" Core_.let_ fieldMap cx) (\field_input -> Eithers.bind (Helpers.requireField "output" Core_.let_ fieldMap cx) (\field_output -> Right (Testing.HoistPolymorphicLetBindingsTestCase { - Testing.hoistPolymorphicLetBindingsTestCaseInput = field_input, - Testing.hoistPolymorphicLetBindingsTestCaseOutput = field_output})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -hoistPredicate :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Testing.HoistPredicate -hoistPredicate cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermUnion v0 -> - let field = Core.injectionField v0 - fname = Core.fieldName field - fterm = Core.fieldTerm field - variantMap = - Maps.fromList [ - (Core.Name "caseStatements", (\input -> Eithers.map (\t -> Testing.HoistPredicateCaseStatements) (Helpers.decodeUnit cx input))), - (Core.Name "applications", (\input -> Eithers.map (\t -> Testing.HoistPredicateApplications) (Helpers.decodeUnit cx input))), - (Core.Name "lists", (\input -> Eithers.map (\t -> Testing.HoistPredicateLists) (Helpers.decodeUnit cx input))), - (Core.Name "nothing", (\input -> Eithers.map (\t -> Testing.HoistPredicateNothing) (Helpers.decodeUnit cx input)))] - in (Maybes.maybe (Left (Errors.DecodingError (Strings.cat [ - "no such field ", - (Core.unName fname), - " in union"]))) (\f -> f fterm) (Maps.lookup fname variantMap)) - _ -> Left (Errors.DecodingError "expected union")) (Lexical.stripAndDereferenceTermEither cx raw) - -hoistSubtermsTestCase :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Testing.HoistSubtermsTestCase -hoistSubtermsTestCase cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "predicate" hoistPredicate fieldMap cx) (\field_predicate -> Eithers.bind (Helpers.requireField "input" Core_.term fieldMap cx) (\field_input -> Eithers.bind (Helpers.requireField "output" Core_.term fieldMap cx) (\field_output -> Right (Testing.HoistSubtermsTestCase { - Testing.hoistSubtermsTestCasePredicate = field_predicate, - Testing.hoistSubtermsTestCaseInput = field_input, - Testing.hoistSubtermsTestCaseOutput = field_output}))))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -inferenceFailureTestCase :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Testing.InferenceFailureTestCase -inferenceFailureTestCase cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "input" Core_.term fieldMap cx) (\field_input -> Right (Testing.InferenceFailureTestCase { - Testing.inferenceFailureTestCaseInput = field_input}))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -inferenceTestCase :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Testing.InferenceTestCase -inferenceTestCase cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "input" Core_.term fieldMap cx) (\field_input -> Eithers.bind (Helpers.requireField "output" Core_.typeScheme fieldMap cx) (\field_output -> Right (Testing.InferenceTestCase { - Testing.inferenceTestCaseInput = field_input, - Testing.inferenceTestCaseOutput = field_output})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -joinTypesTestCase :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Testing.JoinTypesTestCase -joinTypesTestCase cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "left" Core_.type_ fieldMap cx) (\field_left -> Eithers.bind (Helpers.requireField "right" Core_.type_ fieldMap cx) (\field_right -> Eithers.bind (Helpers.requireField "expected" (Helpers.decodeEither Helpers.decodeUnit (Helpers.decodeList Typing.typeConstraint)) fieldMap cx) (\field_expected -> Right (Testing.JoinTypesTestCase { - Testing.joinTypesTestCaseLeft = field_left, - Testing.joinTypesTestCaseRight = field_right, - Testing.joinTypesTestCaseExpected = field_expected}))))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -jsonDecodeTestCase :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Testing.JsonDecodeTestCase -jsonDecodeTestCase cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "type" Core_.type_ fieldMap cx) (\field_type -> Eithers.bind (Helpers.requireField "json" Model.value fieldMap cx) (\field_json -> Eithers.bind (Helpers.requireField "expected" (Helpers.decodeEither (\cx -> \raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw)) Core_.term) fieldMap cx) (\field_expected -> Right (Testing.JsonDecodeTestCase { - Testing.jsonDecodeTestCaseType = field_type, - Testing.jsonDecodeTestCaseJson = field_json, - Testing.jsonDecodeTestCaseExpected = field_expected}))))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -jsonEncodeTestCase :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Testing.JsonEncodeTestCase -jsonEncodeTestCase cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "term" Core_.term fieldMap cx) (\field_term -> Eithers.bind (Helpers.requireField "expected" (Helpers.decodeEither (\cx -> \raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw)) Model.value) fieldMap cx) (\field_expected -> Right (Testing.JsonEncodeTestCase { - Testing.jsonEncodeTestCaseTerm = field_term, - Testing.jsonEncodeTestCaseExpected = field_expected})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -jsonParserTestCase :: Graph.Graph -> Core.Term -> Either Errors.DecodingError (Testing.ParserTestCase Model_.Value) -jsonParserTestCase = parserTestCase Model.value - -jsonRoundtripTestCase :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Testing.JsonRoundtripTestCase -jsonRoundtripTestCase cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "type" Core_.type_ fieldMap cx) (\field_type -> Eithers.bind (Helpers.requireField "term" Core_.term fieldMap cx) (\field_term -> Right (Testing.JsonRoundtripTestCase { - Testing.jsonRoundtripTestCaseType = field_type, - Testing.jsonRoundtripTestCaseTerm = field_term})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -jsonWriterTestCase :: Graph.Graph -> Core.Term -> Either Errors.DecodingError (Testing.WriterTestCase Model_.Value) -jsonWriterTestCase = writerTestCase Model.value - -liftLambdaAboveLetTestCase :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Testing.LiftLambdaAboveLetTestCase -liftLambdaAboveLetTestCase cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "input" Core_.term fieldMap cx) (\field_input -> Eithers.bind (Helpers.requireField "output" Core_.term fieldMap cx) (\field_output -> Right (Testing.LiftLambdaAboveLetTestCase { - Testing.liftLambdaAboveLetTestCaseInput = field_input, - Testing.liftLambdaAboveLetTestCaseOutput = field_output})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -normalizeTypeVariablesTestCase :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Testing.NormalizeTypeVariablesTestCase -normalizeTypeVariablesTestCase cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "input" Core_.term fieldMap cx) (\field_input -> Eithers.bind (Helpers.requireField "output" Core_.term fieldMap cx) (\field_output -> Right (Testing.NormalizeTypeVariablesTestCase { - Testing.normalizeTypeVariablesTestCaseInput = field_input, - Testing.normalizeTypeVariablesTestCaseOutput = field_output})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -parserTestCase :: (Graph.Graph -> Core.Term -> Either Errors.DecodingError t0) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (Testing.ParserTestCase t0) -parserTestCase a cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "input" (\cx -> \raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw)) fieldMap cx) (\field_input -> Eithers.bind (Helpers.requireField "output" (Parsing.parseResult a) fieldMap cx) (\field_output -> Right (Testing.ParserTestCase { - Testing.parserTestCaseInput = field_input, - Testing.parserTestCaseOutput = field_output})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -rewriteTermTestCase :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Testing.RewriteTermTestCase -rewriteTermTestCase cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "input" Core_.term fieldMap cx) (\field_input -> Eithers.bind (Helpers.requireField "rewriter" termRewriter fieldMap cx) (\field_rewriter -> Eithers.bind (Helpers.requireField "output" Core_.term fieldMap cx) (\field_output -> Right (Testing.RewriteTermTestCase { - Testing.rewriteTermTestCaseInput = field_input, - Testing.rewriteTermTestCaseRewriter = field_rewriter, - Testing.rewriteTermTestCaseOutput = field_output}))))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -rewriteTypeTestCase :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Testing.RewriteTypeTestCase -rewriteTypeTestCase cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "input" Core_.type_ fieldMap cx) (\field_input -> Eithers.bind (Helpers.requireField "rewriter" typeRewriter fieldMap cx) (\field_rewriter -> Eithers.bind (Helpers.requireField "output" Core_.type_ fieldMap cx) (\field_output -> Right (Testing.RewriteTypeTestCase { - Testing.rewriteTypeTestCaseInput = field_input, - Testing.rewriteTypeTestCaseRewriter = field_rewriter, - Testing.rewriteTypeTestCaseOutput = field_output}))))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -serializationTestCase :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Testing.SerializationTestCase -serializationTestCase cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "input" Ast.expr fieldMap cx) (\field_input -> Eithers.bind (Helpers.requireField "output" (\cx -> \raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw)) fieldMap cx) (\field_output -> Right (Testing.SerializationTestCase { - Testing.serializationTestCaseInput = field_input, - Testing.serializationTestCaseOutput = field_output})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -simplifyTermTestCase :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Testing.SimplifyTermTestCase -simplifyTermTestCase cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "input" Core_.term fieldMap cx) (\field_input -> Eithers.bind (Helpers.requireField "output" Core_.term fieldMap cx) (\field_output -> Right (Testing.SimplifyTermTestCase { - Testing.simplifyTermTestCaseInput = field_input, - Testing.simplifyTermTestCaseOutput = field_output})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -substInTypeTestCase :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Testing.SubstInTypeTestCase -substInTypeTestCase cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "substitution" (Helpers.decodeList (Helpers.decodePair Core_.name Core_.type_)) fieldMap cx) (\field_substitution -> Eithers.bind (Helpers.requireField "input" Core_.type_ fieldMap cx) (\field_input -> Eithers.bind (Helpers.requireField "output" Core_.type_ fieldMap cx) (\field_output -> Right (Testing.SubstInTypeTestCase { - Testing.substInTypeTestCaseSubstitution = field_substitution, - Testing.substInTypeTestCaseInput = field_input, - Testing.substInTypeTestCaseOutput = field_output}))))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -tag :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Testing.Tag -tag cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermWrap v0 -> Eithers.map (\b -> Testing.Tag b) ((\raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw)) (Core.wrappedTermBody v0)) - _ -> Left (Errors.DecodingError "expected wrapped type")) (Lexical.stripAndDereferenceTermEither cx raw) - -termRewriter :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Testing.TermRewriter -termRewriter cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermUnion v0 -> - let field = Core.injectionField v0 - fname = Core.fieldName field - fterm = Core.fieldTerm field - variantMap = - Maps.fromList [ - (Core.Name "replaceFooWithBar", (\input -> Eithers.map (\t -> Testing.TermRewriterReplaceFooWithBar) (Helpers.decodeUnit cx input))), - (Core.Name "replaceInt32WithInt64", (\input -> Eithers.map (\t -> Testing.TermRewriterReplaceInt32WithInt64) (Helpers.decodeUnit cx input)))] - in (Maybes.maybe (Left (Errors.DecodingError (Strings.cat [ - "no such field ", - (Core.unName fname), - " in union"]))) (\f -> f fterm) (Maps.lookup fname variantMap)) - _ -> Left (Errors.DecodingError "expected union")) (Lexical.stripAndDereferenceTermEither cx raw) - -testCase :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Testing.TestCase -testCase cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermUnion v0 -> - let field = Core.injectionField v0 - fname = Core.fieldName field - fterm = Core.fieldTerm field - variantMap = - Maps.fromList [ - (Core.Name "alphaConversion", (\input -> Eithers.map (\t -> Testing.TestCaseAlphaConversion t) (alphaConversionTestCase cx input))), - (Core.Name "caseConversion", (\input -> Eithers.map (\t -> Testing.TestCaseCaseConversion t) (caseConversionTestCase cx input))), - (Core.Name "deannotateTerm", (\input -> Eithers.map (\t -> Testing.TestCaseDeannotateTerm t) (deannotateTermTestCase cx input))), - (Core.Name "deannotateType", (\input -> Eithers.map (\t -> Testing.TestCaseDeannotateType t) (deannotateTypeTestCase cx input))), - (Core.Name "delegatedEvaluation", (\input -> Eithers.map (\t -> Testing.TestCaseDelegatedEvaluation t) (delegatedEvaluationTestCase cx input))), - (Core.Name "etaExpansion", (\input -> Eithers.map (\t -> Testing.TestCaseEtaExpansion t) (etaExpansionTestCase cx input))), - (Core.Name "flattenLetTerms", (\input -> Eithers.map (\t -> Testing.TestCaseFlattenLetTerms t) (flattenLetTermsTestCase cx input))), - (Core.Name "freeVariables", (\input -> Eithers.map (\t -> Testing.TestCaseFreeVariables t) (freeVariablesTestCase cx input))), - (Core.Name "evaluation", (\input -> Eithers.map (\t -> Testing.TestCaseEvaluation t) (evaluationTestCase cx input))), - (Core.Name "inference", (\input -> Eithers.map (\t -> Testing.TestCaseInference t) (inferenceTestCase cx input))), - (Core.Name "inferenceFailure", (\input -> Eithers.map (\t -> Testing.TestCaseInferenceFailure t) (inferenceFailureTestCase cx input))), - (Core.Name "jsonDecode", (\input -> Eithers.map (\t -> Testing.TestCaseJsonDecode t) (jsonDecodeTestCase cx input))), - (Core.Name "jsonEncode", (\input -> Eithers.map (\t -> Testing.TestCaseJsonEncode t) (jsonEncodeTestCase cx input))), - (Core.Name "jsonParser", (\input -> Eithers.map (\t -> Testing.TestCaseJsonParser t) (jsonParserTestCase cx input))), - (Core.Name "jsonRoundtrip", (\input -> Eithers.map (\t -> Testing.TestCaseJsonRoundtrip t) (jsonRoundtripTestCase cx input))), - (Core.Name "jsonWriter", (\input -> Eithers.map (\t -> Testing.TestCaseJsonWriter t) (jsonWriterTestCase cx input))), - (Core.Name "liftLambdaAboveLet", (\input -> Eithers.map (\t -> Testing.TestCaseLiftLambdaAboveLet t) (liftLambdaAboveLetTestCase cx input))), - (Core.Name "serialization", (\input -> Eithers.map (\t -> Testing.TestCaseSerialization t) (serializationTestCase cx input))), - (Core.Name "simplifyTerm", (\input -> Eithers.map (\t -> Testing.TestCaseSimplifyTerm t) (simplifyTermTestCase cx input))), - (Core.Name "topologicalSort", (\input -> Eithers.map (\t -> Testing.TestCaseTopologicalSort t) (topologicalSortTestCase cx input))), - (Core.Name "topologicalSortBindings", (\input -> Eithers.map (\t -> Testing.TestCaseTopologicalSortBindings t) (topologicalSortBindingsTestCase cx input))), - (Core.Name "topologicalSortSCC", (\input -> Eithers.map (\t -> Testing.TestCaseTopologicalSortSCC t) (topologicalSortSCCTestCase cx input))), - (Core.Name "typeChecking", (\input -> Eithers.map (\t -> Testing.TestCaseTypeChecking t) (typeCheckingTestCase cx input))), - (Core.Name "typeCheckingFailure", (\input -> Eithers.map (\t -> Testing.TestCaseTypeCheckingFailure t) (typeCheckingFailureTestCase cx input))), - (Core.Name "typeReduction", (\input -> Eithers.map (\t -> Testing.TestCaseTypeReduction t) (typeReductionTestCase cx input))), - (Core.Name "normalizeTypeVariables", (\input -> Eithers.map (\t -> Testing.TestCaseNormalizeTypeVariables t) (normalizeTypeVariablesTestCase cx input))), - (Core.Name "foldOverTerm", (\input -> Eithers.map (\t -> Testing.TestCaseFoldOverTerm t) (foldOverTermTestCase cx input))), - (Core.Name "rewriteTerm", (\input -> Eithers.map (\t -> Testing.TestCaseRewriteTerm t) (rewriteTermTestCase cx input))), - (Core.Name "rewriteType", (\input -> Eithers.map (\t -> Testing.TestCaseRewriteType t) (rewriteTypeTestCase cx input))), - (Core.Name "hoistSubterms", (\input -> Eithers.map (\t -> Testing.TestCaseHoistSubterms t) (hoistSubtermsTestCase cx input))), - (Core.Name "hoistCaseStatements", (\input -> Eithers.map (\t -> Testing.TestCaseHoistCaseStatements t) (hoistCaseStatementsTestCase cx input))), - (Core.Name "hoistLetBindings", (\input -> Eithers.map (\t -> Testing.TestCaseHoistLetBindings t) (hoistLetBindingsTestCase cx input))), - (Core.Name "hoistPolymorphicLetBindings", (\input -> Eithers.map (\t -> Testing.TestCaseHoistPolymorphicLetBindings t) (hoistPolymorphicLetBindingsTestCase cx input))), - (Core.Name "substInType", (\input -> Eithers.map (\t -> Testing.TestCaseSubstInType t) (substInTypeTestCase cx input))), - (Core.Name "variableOccursInType", (\input -> Eithers.map (\t -> Testing.TestCaseVariableOccursInType t) (variableOccursInTypeTestCase cx input))), - (Core.Name "unifyTypes", (\input -> Eithers.map (\t -> Testing.TestCaseUnifyTypes t) (unifyTypesTestCase cx input))), - (Core.Name "joinTypes", (\input -> Eithers.map (\t -> Testing.TestCaseJoinTypes t) (joinTypesTestCase cx input))), - (Core.Name "unshadowVariables", (\input -> Eithers.map (\t -> Testing.TestCaseUnshadowVariables t) (unshadowVariablesTestCase cx input))), - (Core.Name "validateCoreTerm", (\input -> Eithers.map (\t -> Testing.TestCaseValidateCoreTerm t) (validateCoreTermTestCase cx input)))] - in (Maybes.maybe (Left (Errors.DecodingError (Strings.cat [ - "no such field ", - (Core.unName fname), - " in union"]))) (\f -> f fterm) (Maps.lookup fname variantMap)) - _ -> Left (Errors.DecodingError "expected union")) (Lexical.stripAndDereferenceTermEither cx raw) - -testCaseWithMetadata :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Testing.TestCaseWithMetadata -testCaseWithMetadata cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "name" (\cx -> \raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw)) fieldMap cx) (\field_name -> Eithers.bind (Helpers.requireField "case" testCase fieldMap cx) (\field_case -> Eithers.bind (Helpers.requireField "description" (Helpers.decodeMaybe (\cx -> \raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw))) fieldMap cx) (\field_description -> Eithers.bind (Helpers.requireField "tags" (Helpers.decodeList tag) fieldMap cx) (\field_tags -> Right (Testing.TestCaseWithMetadata { - Testing.testCaseWithMetadataName = field_name, - Testing.testCaseWithMetadataCase = field_case, - Testing.testCaseWithMetadataDescription = field_description, - Testing.testCaseWithMetadataTags = field_tags})))))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -testGroup :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Testing.TestGroup -testGroup cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "name" (\cx -> \raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw)) fieldMap cx) (\field_name -> Eithers.bind (Helpers.requireField "description" (Helpers.decodeMaybe (\cx -> \raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw))) fieldMap cx) (\field_description -> Eithers.bind (Helpers.requireField "subgroups" (Helpers.decodeList testGroup) fieldMap cx) (\field_subgroups -> Eithers.bind (Helpers.requireField "cases" (Helpers.decodeList testCaseWithMetadata) fieldMap cx) (\field_cases -> Right (Testing.TestGroup { - Testing.testGroupName = field_name, - Testing.testGroupDescription = field_description, - Testing.testGroupSubgroups = field_subgroups, - Testing.testGroupCases = field_cases})))))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -topologicalSortBindingsTestCase :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Testing.TopologicalSortBindingsTestCase -topologicalSortBindingsTestCase cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "bindings" (Helpers.decodeList (Helpers.decodePair Core_.name Core_.term)) fieldMap cx) (\field_bindings -> Eithers.bind (Helpers.requireField "expected" (Helpers.decodeList (Helpers.decodeList (Helpers.decodePair Core_.name Core_.term))) fieldMap cx) (\field_expected -> Right (Testing.TopologicalSortBindingsTestCase { - Testing.topologicalSortBindingsTestCaseBindings = field_bindings, - Testing.topologicalSortBindingsTestCaseExpected = field_expected})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -topologicalSortSCCTestCase :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Testing.TopologicalSortSCCTestCase -topologicalSortSCCTestCase cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "adjacencyList" (Helpers.decodeList (Helpers.decodePair (\cx -> \raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralInteger v2 -> case v2 of - Core.IntegerValueInt32 v3 -> Right v3 - _ -> Left (Errors.DecodingError "expected int32 value") - _ -> Left (Errors.DecodingError "expected int32 literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw)) (Helpers.decodeList (\cx -> \raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralInteger v2 -> case v2 of - Core.IntegerValueInt32 v3 -> Right v3 - _ -> Left (Errors.DecodingError "expected int32 value") - _ -> Left (Errors.DecodingError "expected int32 literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw))))) fieldMap cx) (\field_adjacencyList -> Eithers.bind (Helpers.requireField "expected" (Helpers.decodeList (Helpers.decodeList (\cx -> \raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralInteger v2 -> case v2 of - Core.IntegerValueInt32 v3 -> Right v3 - _ -> Left (Errors.DecodingError "expected int32 value") - _ -> Left (Errors.DecodingError "expected int32 literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw)))) fieldMap cx) (\field_expected -> Right (Testing.TopologicalSortSCCTestCase { - Testing.topologicalSortSCCTestCaseAdjacencyList = field_adjacencyList, - Testing.topologicalSortSCCTestCaseExpected = field_expected})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -topologicalSortTestCase :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Testing.TopologicalSortTestCase -topologicalSortTestCase cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "adjacencyList" (Helpers.decodeList (Helpers.decodePair (\cx -> \raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralInteger v2 -> case v2 of - Core.IntegerValueInt32 v3 -> Right v3 - _ -> Left (Errors.DecodingError "expected int32 value") - _ -> Left (Errors.DecodingError "expected int32 literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw)) (Helpers.decodeList (\cx -> \raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralInteger v2 -> case v2 of - Core.IntegerValueInt32 v3 -> Right v3 - _ -> Left (Errors.DecodingError "expected int32 value") - _ -> Left (Errors.DecodingError "expected int32 literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw))))) fieldMap cx) (\field_adjacencyList -> Eithers.bind (Helpers.requireField "expected" (Helpers.decodeEither (Helpers.decodeList (Helpers.decodeList (\cx -> \raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralInteger v2 -> case v2 of - Core.IntegerValueInt32 v3 -> Right v3 - _ -> Left (Errors.DecodingError "expected int32 value") - _ -> Left (Errors.DecodingError "expected int32 literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw)))) (Helpers.decodeList (\cx -> \raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralInteger v2 -> case v2 of - Core.IntegerValueInt32 v3 -> Right v3 - _ -> Left (Errors.DecodingError "expected int32 value") - _ -> Left (Errors.DecodingError "expected int32 literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw)))) fieldMap cx) (\field_expected -> Right (Testing.TopologicalSortTestCase { - Testing.topologicalSortTestCaseAdjacencyList = field_adjacencyList, - Testing.topologicalSortTestCaseExpected = field_expected})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -typeCheckingFailureTestCase :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Testing.TypeCheckingFailureTestCase -typeCheckingFailureTestCase cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "input" Core_.term fieldMap cx) (\field_input -> Right (Testing.TypeCheckingFailureTestCase { - Testing.typeCheckingFailureTestCaseInput = field_input}))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -typeCheckingTestCase :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Testing.TypeCheckingTestCase -typeCheckingTestCase cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "input" Core_.term fieldMap cx) (\field_input -> Eithers.bind (Helpers.requireField "outputTerm" Core_.term fieldMap cx) (\field_outputTerm -> Eithers.bind (Helpers.requireField "outputType" Core_.type_ fieldMap cx) (\field_outputType -> Right (Testing.TypeCheckingTestCase { - Testing.typeCheckingTestCaseInput = field_input, - Testing.typeCheckingTestCaseOutputTerm = field_outputTerm, - Testing.typeCheckingTestCaseOutputType = field_outputType}))))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -typeReductionTestCase :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Testing.TypeReductionTestCase -typeReductionTestCase cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "input" Core_.type_ fieldMap cx) (\field_input -> Eithers.bind (Helpers.requireField "output" Core_.type_ fieldMap cx) (\field_output -> Right (Testing.TypeReductionTestCase { - Testing.typeReductionTestCaseInput = field_input, - Testing.typeReductionTestCaseOutput = field_output})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -typeRewriter :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Testing.TypeRewriter -typeRewriter cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermUnion v0 -> - let field = Core.injectionField v0 - fname = Core.fieldName field - fterm = Core.fieldTerm field - variantMap = - Maps.fromList [ - (Core.Name "replaceStringWithInt32", (\input -> Eithers.map (\t -> Testing.TypeRewriterReplaceStringWithInt32) (Helpers.decodeUnit cx input)))] - in (Maybes.maybe (Left (Errors.DecodingError (Strings.cat [ - "no such field ", - (Core.unName fname), - " in union"]))) (\f -> f fterm) (Maps.lookup fname variantMap)) - _ -> Left (Errors.DecodingError "expected union")) (Lexical.stripAndDereferenceTermEither cx raw) - -unifyTypesTestCase :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Testing.UnifyTypesTestCase -unifyTypesTestCase cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "schemaTypes" (Helpers.decodeList Core_.name) fieldMap cx) (\field_schemaTypes -> Eithers.bind (Helpers.requireField "left" Core_.type_ fieldMap cx) (\field_left -> Eithers.bind (Helpers.requireField "right" Core_.type_ fieldMap cx) (\field_right -> Eithers.bind (Helpers.requireField "expected" (Helpers.decodeEither (\cx -> \raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw)) Typing.typeSubst) fieldMap cx) (\field_expected -> Right (Testing.UnifyTypesTestCase { - Testing.unifyTypesTestCaseSchemaTypes = field_schemaTypes, - Testing.unifyTypesTestCaseLeft = field_left, - Testing.unifyTypesTestCaseRight = field_right, - Testing.unifyTypesTestCaseExpected = field_expected})))))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -unshadowVariablesTestCase :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Testing.UnshadowVariablesTestCase -unshadowVariablesTestCase cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "input" Core_.term fieldMap cx) (\field_input -> Eithers.bind (Helpers.requireField "output" Core_.term fieldMap cx) (\field_output -> Right (Testing.UnshadowVariablesTestCase { - Testing.unshadowVariablesTestCaseInput = field_input, - Testing.unshadowVariablesTestCaseOutput = field_output})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -validateCoreTermTestCase :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Testing.ValidateCoreTermTestCase -validateCoreTermTestCase cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "typed" (\cx -> \raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralBoolean v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected boolean literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw)) fieldMap cx) (\field_typed -> Eithers.bind (Helpers.requireField "input" Core_.term fieldMap cx) (\field_input -> Eithers.bind (Helpers.requireField "output" (Helpers.decodeMaybe Core__.invalidTermError) fieldMap cx) (\field_output -> Right (Testing.ValidateCoreTermTestCase { - Testing.validateCoreTermTestCaseTyped = field_typed, - Testing.validateCoreTermTestCaseInput = field_input, - Testing.validateCoreTermTestCaseOutput = field_output}))))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -variableOccursInTypeTestCase :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Testing.VariableOccursInTypeTestCase -variableOccursInTypeTestCase cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "variable" Core_.name fieldMap cx) (\field_variable -> Eithers.bind (Helpers.requireField "type" Core_.type_ fieldMap cx) (\field_type -> Eithers.bind (Helpers.requireField "expected" (\cx -> \raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralBoolean v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected boolean literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw)) fieldMap cx) (\field_expected -> Right (Testing.VariableOccursInTypeTestCase { - Testing.variableOccursInTypeTestCaseVariable = field_variable, - Testing.variableOccursInTypeTestCaseType = field_type, - Testing.variableOccursInTypeTestCaseExpected = field_expected}))))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -writerTestCase :: (Graph.Graph -> Core.Term -> Either Errors.DecodingError t0) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (Testing.WriterTestCase t0) -writerTestCase a cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "input" a fieldMap cx) (\field_input -> Eithers.bind (Helpers.requireField "output" (\cx -> \raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw)) fieldMap cx) (\field_output -> Right (Testing.WriterTestCase { - Testing.writerTestCaseInput = field_input, - Testing.writerTestCaseOutput = field_output})))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) diff --git a/src/gen-main/haskell/Hydra/Decode/Topology.hs b/src/gen-main/haskell/Hydra/Decode/Topology.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Decode/Topology.hs +++ /dev/null @@ -1,64 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Term decoders for hydra.topology - -module Hydra.Decode.Topology where - -import qualified Hydra.Core as Core -import qualified Hydra.Errors as Errors -import qualified Hydra.Extract.Helpers as Helpers -import qualified Hydra.Graph as Graph -import qualified Hydra.Lexical as Lexical -import qualified Hydra.Lib.Eithers as Eithers -import qualified Hydra.Topology as Topology -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -graph :: Graph.Graph -> Core.Term -> Either Errors.DecodingError (M.Map Int [Int]) -graph = Helpers.decodeMap vertex (Helpers.decodeList vertex) - -tarjanState :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Topology.TarjanState -tarjanState cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "counter" (\cx -> \raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralInteger v2 -> case v2 of - Core.IntegerValueInt32 v3 -> Right v3 - _ -> Left (Errors.DecodingError "expected int32 value") - _ -> Left (Errors.DecodingError "expected int32 literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw)) fieldMap cx) (\field_counter -> Eithers.bind (Helpers.requireField "indices" (Helpers.decodeMap vertex (\cx -> \raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralInteger v2 -> case v2 of - Core.IntegerValueInt32 v3 -> Right v3 - _ -> Left (Errors.DecodingError "expected int32 value") - _ -> Left (Errors.DecodingError "expected int32 literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw))) fieldMap cx) (\field_indices -> Eithers.bind (Helpers.requireField "lowLinks" (Helpers.decodeMap vertex (\cx -> \raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralInteger v2 -> case v2 of - Core.IntegerValueInt32 v3 -> Right v3 - _ -> Left (Errors.DecodingError "expected int32 value") - _ -> Left (Errors.DecodingError "expected int32 literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw))) fieldMap cx) (\field_lowLinks -> Eithers.bind (Helpers.requireField "stack" (Helpers.decodeList vertex) fieldMap cx) (\field_stack -> Eithers.bind (Helpers.requireField "onStack" (Helpers.decodeSet vertex) fieldMap cx) (\field_onStack -> Eithers.bind (Helpers.requireField "sccs" (Helpers.decodeList (Helpers.decodeList vertex)) fieldMap cx) (\field_sccs -> Right (Topology.TarjanState { - Topology.tarjanStateCounter = field_counter, - Topology.tarjanStateIndices = field_indices, - Topology.tarjanStateLowLinks = field_lowLinks, - Topology.tarjanStateStack = field_stack, - Topology.tarjanStateOnStack = field_onStack, - Topology.tarjanStateSccs = field_sccs})))))))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -vertex :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Int -vertex cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v0 -> case v0 of - Core.LiteralInteger v1 -> case v1 of - Core.IntegerValueInt32 v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected int32 value") - _ -> Left (Errors.DecodingError "expected int32 literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw) diff --git a/src/gen-main/haskell/Hydra/Decode/Typing.hs b/src/gen-main/haskell/Hydra/Decode/Typing.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Decode/Typing.hs +++ /dev/null @@ -1,76 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Term decoders for hydra.typing - -module Hydra.Decode.Typing where - -import qualified Hydra.Core as Core -import qualified Hydra.Decode.Context as Context -import qualified Hydra.Decode.Core as Core_ -import qualified Hydra.Errors as Errors -import qualified Hydra.Extract.Helpers as Helpers -import qualified Hydra.Graph as Graph -import qualified Hydra.Lexical as Lexical -import qualified Hydra.Lib.Eithers as Eithers -import qualified Hydra.Typing as Typing -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -functionStructure :: (Graph.Graph -> Core.Term -> Either Errors.DecodingError t0) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (Typing.FunctionStructure t0) -functionStructure env cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "typeParams" (Helpers.decodeList Core_.name) fieldMap cx) (\field_typeParams -> Eithers.bind (Helpers.requireField "params" (Helpers.decodeList Core_.name) fieldMap cx) (\field_params -> Eithers.bind (Helpers.requireField "bindings" (Helpers.decodeList Core_.binding) fieldMap cx) (\field_bindings -> Eithers.bind (Helpers.requireField "body" Core_.term fieldMap cx) (\field_body -> Eithers.bind (Helpers.requireField "domains" (Helpers.decodeList Core_.type_) fieldMap cx) (\field_domains -> Eithers.bind (Helpers.requireField "codomain" (Helpers.decodeMaybe Core_.type_) fieldMap cx) (\field_codomain -> Eithers.bind (Helpers.requireField "environment" env fieldMap cx) (\field_environment -> Right (Typing.FunctionStructure { - Typing.functionStructureTypeParams = field_typeParams, - Typing.functionStructureParams = field_params, - Typing.functionStructureBindings = field_bindings, - Typing.functionStructureBody = field_body, - Typing.functionStructureDomains = field_domains, - Typing.functionStructureCodomain = field_codomain, - Typing.functionStructureEnvironment = field_environment}))))))))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -inferenceResult :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Typing.InferenceResult -inferenceResult cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "term" Core_.term fieldMap cx) (\field_term -> Eithers.bind (Helpers.requireField "type" Core_.type_ fieldMap cx) (\field_type -> Eithers.bind (Helpers.requireField "subst" typeSubst fieldMap cx) (\field_subst -> Eithers.bind (Helpers.requireField "classConstraints" (Helpers.decodeMap Core_.name Core_.typeVariableMetadata) fieldMap cx) (\field_classConstraints -> Eithers.bind (Helpers.requireField "context" Context.context fieldMap cx) (\field_context -> Right (Typing.InferenceResult { - Typing.inferenceResultTerm = field_term, - Typing.inferenceResultType = field_type, - Typing.inferenceResultSubst = field_subst, - Typing.inferenceResultClassConstraints = field_classConstraints, - Typing.inferenceResultContext = field_context}))))))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -termSubst :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Typing.TermSubst -termSubst cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermWrap v0 -> Eithers.map (\b -> Typing.TermSubst b) (Helpers.decodeMap Core_.name Core_.term cx (Core.wrappedTermBody v0)) - _ -> Left (Errors.DecodingError "expected wrapped type")) (Lexical.stripAndDereferenceTermEither cx raw) - -typeConstraint :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Typing.TypeConstraint -typeConstraint cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermRecord v0 -> - let fieldMap = Helpers.toFieldMap v0 - in (Eithers.bind (Helpers.requireField "left" Core_.type_ fieldMap cx) (\field_left -> Eithers.bind (Helpers.requireField "right" Core_.type_ fieldMap cx) (\field_right -> Eithers.bind (Helpers.requireField "comment" (\cx -> \raw -> Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralString v2 -> Right v2 - _ -> Left (Errors.DecodingError "expected string literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx raw)) fieldMap cx) (\field_comment -> Right (Typing.TypeConstraint { - Typing.typeConstraintLeft = field_left, - Typing.typeConstraintRight = field_right, - Typing.typeConstraintComment = field_comment}))))) - _ -> Left (Errors.DecodingError "expected record")) (Lexical.stripAndDereferenceTermEither cx raw) - -typeSubst :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Typing.TypeSubst -typeSubst cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermWrap v0 -> Eithers.map (\b -> Typing.TypeSubst b) (Helpers.decodeMap Core_.name Core_.type_ cx (Core.wrappedTermBody v0)) - _ -> Left (Errors.DecodingError "expected wrapped type")) (Lexical.stripAndDereferenceTermEither cx raw) diff --git a/src/gen-main/haskell/Hydra/Decode/Util.hs b/src/gen-main/haskell/Hydra/Decode/Util.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Decode/Util.hs +++ /dev/null @@ -1,82 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Term decoders for hydra.util - -module Hydra.Decode.Util where - -import qualified Hydra.Core as Core -import qualified Hydra.Errors as Errors -import qualified Hydra.Extract.Helpers as Helpers -import qualified Hydra.Graph as Graph -import qualified Hydra.Lexical as Lexical -import qualified Hydra.Lib.Eithers as Eithers -import qualified Hydra.Lib.Maps as Maps -import qualified Hydra.Lib.Maybes as Maybes -import qualified Hydra.Lib.Strings as Strings -import qualified Hydra.Util as Util -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -caseConvention :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Util.CaseConvention -caseConvention cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermUnion v0 -> - let field = Core.injectionField v0 - fname = Core.fieldName field - fterm = Core.fieldTerm field - variantMap = - Maps.fromList [ - (Core.Name "camel", (\input -> Eithers.map (\t -> Util.CaseConventionCamel) (Helpers.decodeUnit cx input))), - (Core.Name "pascal", (\input -> Eithers.map (\t -> Util.CaseConventionPascal) (Helpers.decodeUnit cx input))), - (Core.Name "lowerSnake", (\input -> Eithers.map (\t -> Util.CaseConventionLowerSnake) (Helpers.decodeUnit cx input))), - (Core.Name "upperSnake", (\input -> Eithers.map (\t -> Util.CaseConventionUpperSnake) (Helpers.decodeUnit cx input)))] - in (Maybes.maybe (Left (Errors.DecodingError (Strings.cat [ - "no such field ", - (Core.unName fname), - " in union"]))) (\f -> f fterm) (Maps.lookup fname variantMap)) - _ -> Left (Errors.DecodingError "expected union")) (Lexical.stripAndDereferenceTermEither cx raw) - -comparison :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Util.Comparison -comparison cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermUnion v0 -> - let field = Core.injectionField v0 - fname = Core.fieldName field - fterm = Core.fieldTerm field - variantMap = - Maps.fromList [ - (Core.Name "lessThan", (\input -> Eithers.map (\t -> Util.ComparisonLessThan) (Helpers.decodeUnit cx input))), - (Core.Name "equalTo", (\input -> Eithers.map (\t -> Util.ComparisonEqualTo) (Helpers.decodeUnit cx input))), - (Core.Name "greaterThan", (\input -> Eithers.map (\t -> Util.ComparisonGreaterThan) (Helpers.decodeUnit cx input)))] - in (Maybes.maybe (Left (Errors.DecodingError (Strings.cat [ - "no such field ", - (Core.unName fname), - " in union"]))) (\f -> f fterm) (Maps.lookup fname variantMap)) - _ -> Left (Errors.DecodingError "expected union")) (Lexical.stripAndDereferenceTermEither cx raw) - -precision :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Util.Precision -precision cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermUnion v0 -> - let field = Core.injectionField v0 - fname = Core.fieldName field - fterm = Core.fieldTerm field - variantMap = - Maps.fromList [ - (Core.Name "arbitrary", (\input -> Eithers.map (\t -> Util.PrecisionArbitrary) (Helpers.decodeUnit cx input))), - (Core.Name "bits", (\input -> Eithers.map (\t -> Util.PrecisionBits t) (Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermLiteral v1 -> case v1 of - Core.LiteralInteger v2 -> case v2 of - Core.IntegerValueInt32 v3 -> Right v3 - _ -> Left (Errors.DecodingError "expected int32 value") - _ -> Left (Errors.DecodingError "expected int32 literal") - _ -> Left (Errors.DecodingError "expected literal")) (Lexical.stripAndDereferenceTermEither cx input))))] - in (Maybes.maybe (Left (Errors.DecodingError (Strings.cat [ - "no such field ", - (Core.unName fname), - " in union"]))) (\f -> f fterm) (Maps.lookup fname variantMap)) - _ -> Left (Errors.DecodingError "expected union")) (Lexical.stripAndDereferenceTermEither cx raw) diff --git a/src/gen-main/haskell/Hydra/Decode/Variants.hs b/src/gen-main/haskell/Hydra/Decode/Variants.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Decode/Variants.hs +++ /dev/null @@ -1,143 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Term decoders for hydra.variants - -module Hydra.Decode.Variants where - -import qualified Hydra.Core as Core -import qualified Hydra.Errors as Errors -import qualified Hydra.Extract.Helpers as Helpers -import qualified Hydra.Graph as Graph -import qualified Hydra.Lexical as Lexical -import qualified Hydra.Lib.Eithers as Eithers -import qualified Hydra.Lib.Maps as Maps -import qualified Hydra.Lib.Maybes as Maybes -import qualified Hydra.Lib.Strings as Strings -import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -eliminationVariant :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Variants.EliminationVariant -eliminationVariant cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermUnion v0 -> - let field = Core.injectionField v0 - fname = Core.fieldName field - fterm = Core.fieldTerm field - variantMap = - Maps.fromList [ - (Core.Name "record", (\input -> Eithers.map (\t -> Variants.EliminationVariantRecord) (Helpers.decodeUnit cx input))), - (Core.Name "union", (\input -> Eithers.map (\t -> Variants.EliminationVariantUnion) (Helpers.decodeUnit cx input))), - (Core.Name "wrap", (\input -> Eithers.map (\t -> Variants.EliminationVariantWrap) (Helpers.decodeUnit cx input)))] - in (Maybes.maybe (Left (Errors.DecodingError (Strings.cat [ - "no such field ", - (Core.unName fname), - " in union"]))) (\f -> f fterm) (Maps.lookup fname variantMap)) - _ -> Left (Errors.DecodingError "expected union")) (Lexical.stripAndDereferenceTermEither cx raw) - -functionVariant :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Variants.FunctionVariant -functionVariant cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermUnion v0 -> - let field = Core.injectionField v0 - fname = Core.fieldName field - fterm = Core.fieldTerm field - variantMap = - Maps.fromList [ - (Core.Name "elimination", (\input -> Eithers.map (\t -> Variants.FunctionVariantElimination) (Helpers.decodeUnit cx input))), - (Core.Name "lambda", (\input -> Eithers.map (\t -> Variants.FunctionVariantLambda) (Helpers.decodeUnit cx input))), - (Core.Name "primitive", (\input -> Eithers.map (\t -> Variants.FunctionVariantPrimitive) (Helpers.decodeUnit cx input)))] - in (Maybes.maybe (Left (Errors.DecodingError (Strings.cat [ - "no such field ", - (Core.unName fname), - " in union"]))) (\f -> f fterm) (Maps.lookup fname variantMap)) - _ -> Left (Errors.DecodingError "expected union")) (Lexical.stripAndDereferenceTermEither cx raw) - -literalVariant :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Variants.LiteralVariant -literalVariant cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermUnion v0 -> - let field = Core.injectionField v0 - fname = Core.fieldName field - fterm = Core.fieldTerm field - variantMap = - Maps.fromList [ - (Core.Name "binary", (\input -> Eithers.map (\t -> Variants.LiteralVariantBinary) (Helpers.decodeUnit cx input))), - (Core.Name "boolean", (\input -> Eithers.map (\t -> Variants.LiteralVariantBoolean) (Helpers.decodeUnit cx input))), - (Core.Name "float", (\input -> Eithers.map (\t -> Variants.LiteralVariantFloat) (Helpers.decodeUnit cx input))), - (Core.Name "integer", (\input -> Eithers.map (\t -> Variants.LiteralVariantInteger) (Helpers.decodeUnit cx input))), - (Core.Name "string", (\input -> Eithers.map (\t -> Variants.LiteralVariantString) (Helpers.decodeUnit cx input)))] - in (Maybes.maybe (Left (Errors.DecodingError (Strings.cat [ - "no such field ", - (Core.unName fname), - " in union"]))) (\f -> f fterm) (Maps.lookup fname variantMap)) - _ -> Left (Errors.DecodingError "expected union")) (Lexical.stripAndDereferenceTermEither cx raw) - -termVariant :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Variants.TermVariant -termVariant cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermUnion v0 -> - let field = Core.injectionField v0 - fname = Core.fieldName field - fterm = Core.fieldTerm field - variantMap = - Maps.fromList [ - (Core.Name "annotated", (\input -> Eithers.map (\t -> Variants.TermVariantAnnotated) (Helpers.decodeUnit cx input))), - (Core.Name "application", (\input -> Eithers.map (\t -> Variants.TermVariantApplication) (Helpers.decodeUnit cx input))), - (Core.Name "either", (\input -> Eithers.map (\t -> Variants.TermVariantEither) (Helpers.decodeUnit cx input))), - (Core.Name "function", (\input -> Eithers.map (\t -> Variants.TermVariantFunction) (Helpers.decodeUnit cx input))), - (Core.Name "let", (\input -> Eithers.map (\t -> Variants.TermVariantLet) (Helpers.decodeUnit cx input))), - (Core.Name "list", (\input -> Eithers.map (\t -> Variants.TermVariantList) (Helpers.decodeUnit cx input))), - (Core.Name "literal", (\input -> Eithers.map (\t -> Variants.TermVariantLiteral) (Helpers.decodeUnit cx input))), - (Core.Name "map", (\input -> Eithers.map (\t -> Variants.TermVariantMap) (Helpers.decodeUnit cx input))), - (Core.Name "maybe", (\input -> Eithers.map (\t -> Variants.TermVariantMaybe) (Helpers.decodeUnit cx input))), - (Core.Name "pair", (\input -> Eithers.map (\t -> Variants.TermVariantPair) (Helpers.decodeUnit cx input))), - (Core.Name "record", (\input -> Eithers.map (\t -> Variants.TermVariantRecord) (Helpers.decodeUnit cx input))), - (Core.Name "set", (\input -> Eithers.map (\t -> Variants.TermVariantSet) (Helpers.decodeUnit cx input))), - (Core.Name "typeApplication", (\input -> Eithers.map (\t -> Variants.TermVariantTypeApplication) (Helpers.decodeUnit cx input))), - (Core.Name "typeLambda", (\input -> Eithers.map (\t -> Variants.TermVariantTypeLambda) (Helpers.decodeUnit cx input))), - (Core.Name "union", (\input -> Eithers.map (\t -> Variants.TermVariantUnion) (Helpers.decodeUnit cx input))), - (Core.Name "unit", (\input -> Eithers.map (\t -> Variants.TermVariantUnit) (Helpers.decodeUnit cx input))), - (Core.Name "variable", (\input -> Eithers.map (\t -> Variants.TermVariantVariable) (Helpers.decodeUnit cx input))), - (Core.Name "wrap", (\input -> Eithers.map (\t -> Variants.TermVariantWrap) (Helpers.decodeUnit cx input)))] - in (Maybes.maybe (Left (Errors.DecodingError (Strings.cat [ - "no such field ", - (Core.unName fname), - " in union"]))) (\f -> f fterm) (Maps.lookup fname variantMap)) - _ -> Left (Errors.DecodingError "expected union")) (Lexical.stripAndDereferenceTermEither cx raw) - -typeVariant :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Variants.TypeVariant -typeVariant cx raw = - Eithers.either (\err -> Left (Errors.DecodingError err)) (\stripped -> case stripped of - Core.TermUnion v0 -> - let field = Core.injectionField v0 - fname = Core.fieldName field - fterm = Core.fieldTerm field - variantMap = - Maps.fromList [ - (Core.Name "annotated", (\input -> Eithers.map (\t -> Variants.TypeVariantAnnotated) (Helpers.decodeUnit cx input))), - (Core.Name "application", (\input -> Eithers.map (\t -> Variants.TypeVariantApplication) (Helpers.decodeUnit cx input))), - (Core.Name "either", (\input -> Eithers.map (\t -> Variants.TypeVariantEither) (Helpers.decodeUnit cx input))), - (Core.Name "forall", (\input -> Eithers.map (\t -> Variants.TypeVariantForall) (Helpers.decodeUnit cx input))), - (Core.Name "function", (\input -> Eithers.map (\t -> Variants.TypeVariantFunction) (Helpers.decodeUnit cx input))), - (Core.Name "list", (\input -> Eithers.map (\t -> Variants.TypeVariantList) (Helpers.decodeUnit cx input))), - (Core.Name "literal", (\input -> Eithers.map (\t -> Variants.TypeVariantLiteral) (Helpers.decodeUnit cx input))), - (Core.Name "map", (\input -> Eithers.map (\t -> Variants.TypeVariantMap) (Helpers.decodeUnit cx input))), - (Core.Name "maybe", (\input -> Eithers.map (\t -> Variants.TypeVariantMaybe) (Helpers.decodeUnit cx input))), - (Core.Name "pair", (\input -> Eithers.map (\t -> Variants.TypeVariantPair) (Helpers.decodeUnit cx input))), - (Core.Name "record", (\input -> Eithers.map (\t -> Variants.TypeVariantRecord) (Helpers.decodeUnit cx input))), - (Core.Name "set", (\input -> Eithers.map (\t -> Variants.TypeVariantSet) (Helpers.decodeUnit cx input))), - (Core.Name "union", (\input -> Eithers.map (\t -> Variants.TypeVariantUnion) (Helpers.decodeUnit cx input))), - (Core.Name "unit", (\input -> Eithers.map (\t -> Variants.TypeVariantUnit) (Helpers.decodeUnit cx input))), - (Core.Name "variable", (\input -> Eithers.map (\t -> Variants.TypeVariantVariable) (Helpers.decodeUnit cx input))), - (Core.Name "void", (\input -> Eithers.map (\t -> Variants.TypeVariantVoid) (Helpers.decodeUnit cx input))), - (Core.Name "wrap", (\input -> Eithers.map (\t -> Variants.TypeVariantWrap) (Helpers.decodeUnit cx input)))] - in (Maybes.maybe (Left (Errors.DecodingError (Strings.cat [ - "no such field ", - (Core.unName fname), - " in union"]))) (\f -> f fterm) (Maps.lookup fname variantMap)) - _ -> Left (Errors.DecodingError "expected union")) (Lexical.stripAndDereferenceTermEither cx raw) diff --git a/src/gen-main/haskell/Hydra/Decoding.hs b/src/gen-main/haskell/Hydra/Decoding.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Decoding.hs +++ /dev/null @@ -1,1659 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Functions for generating term decoders from type modules - -module Hydra.Decoding where - -import qualified Hydra.Annotations as Annotations -import qualified Hydra.Context as Context -import qualified Hydra.Core as Core -import qualified Hydra.Decode.Core as Core_ -import qualified Hydra.Errors as Errors -import qualified Hydra.Extract.Helpers as Helpers -import qualified Hydra.Formatting as Formatting -import qualified Hydra.Graph as Graph -import qualified Hydra.Lib.Eithers as Eithers -import qualified Hydra.Lib.Lists as Lists -import qualified Hydra.Lib.Logic as Logic -import qualified Hydra.Lib.Maps as Maps -import qualified Hydra.Lib.Maybes as Maybes -import qualified Hydra.Lib.Sets as Sets -import qualified Hydra.Lib.Strings as Strings -import qualified Hydra.Module as Module -import qualified Hydra.Names as Names -import qualified Hydra.Schemas as Schemas -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | Collect forall type variable names from a type -collectForallVariables :: Core.Type -> [Core.Name] -collectForallVariables typ = - case typ of - Core.TypeAnnotated v0 -> collectForallVariables (Core.annotatedTypeBody v0) - Core.TypeForall v0 -> Lists.cons (Core.forallTypeParameter v0) (collectForallVariables (Core.forallTypeBody v0)) - _ -> [] - --- | Collect type variables needing Ord constraints (from Map key and Set element types) -collectOrdConstrainedVariables :: Core.Type -> [Core.Name] -collectOrdConstrainedVariables typ = - case typ of - Core.TypeAnnotated v0 -> collectOrdConstrainedVariables (Core.annotatedTypeBody v0) - Core.TypeApplication v0 -> Lists.concat2 (collectOrdConstrainedVariables (Core.applicationTypeFunction v0)) (collectOrdConstrainedVariables (Core.applicationTypeArgument v0)) - Core.TypeEither v0 -> Lists.concat2 (collectOrdConstrainedVariables (Core.eitherTypeLeft v0)) (collectOrdConstrainedVariables (Core.eitherTypeRight v0)) - Core.TypeForall v0 -> collectOrdConstrainedVariables (Core.forallTypeBody v0) - Core.TypeList v0 -> collectOrdConstrainedVariables v0 - Core.TypeMap v0 -> Lists.concat [ - collectTypeVariablesFromType (Core.mapTypeKeys v0), - (collectOrdConstrainedVariables (Core.mapTypeKeys v0)), - (collectOrdConstrainedVariables (Core.mapTypeValues v0))] - Core.TypeMaybe v0 -> collectOrdConstrainedVariables v0 - Core.TypePair v0 -> Lists.concat2 (collectOrdConstrainedVariables (Core.pairTypeFirst v0)) (collectOrdConstrainedVariables (Core.pairTypeSecond v0)) - Core.TypeRecord v0 -> Lists.concat (Lists.map (\ft -> collectOrdConstrainedVariables (Core.fieldTypeType ft)) v0) - Core.TypeSet v0 -> Lists.concat2 (collectTypeVariablesFromType v0) (collectOrdConstrainedVariables v0) - Core.TypeUnion v0 -> Lists.concat (Lists.map (\ft -> collectOrdConstrainedVariables (Core.fieldTypeType ft)) v0) - Core.TypeWrap v0 -> collectOrdConstrainedVariables v0 - _ -> [] - --- | Collect type variable names from a type (forall parameters only) -collectTypeVariables :: Core.Type -> [Core.Name] -collectTypeVariables typ = collectForallVariables typ - --- | Collect all type variable names from a type expression -collectTypeVariablesFromType :: Core.Type -> [Core.Name] -collectTypeVariablesFromType typ = - case typ of - Core.TypeAnnotated v0 -> collectTypeVariablesFromType (Core.annotatedTypeBody v0) - Core.TypeApplication v0 -> Lists.concat2 (collectTypeVariablesFromType (Core.applicationTypeFunction v0)) (collectTypeVariablesFromType (Core.applicationTypeArgument v0)) - Core.TypeEither v0 -> Lists.concat2 (collectTypeVariablesFromType (Core.eitherTypeLeft v0)) (collectTypeVariablesFromType (Core.eitherTypeRight v0)) - Core.TypeForall v0 -> collectTypeVariablesFromType (Core.forallTypeBody v0) - Core.TypeList v0 -> collectTypeVariablesFromType v0 - Core.TypeMap v0 -> Lists.concat2 (collectTypeVariablesFromType (Core.mapTypeKeys v0)) (collectTypeVariablesFromType (Core.mapTypeValues v0)) - Core.TypeMaybe v0 -> collectTypeVariablesFromType v0 - Core.TypePair v0 -> Lists.concat2 (collectTypeVariablesFromType (Core.pairTypeFirst v0)) (collectTypeVariablesFromType (Core.pairTypeSecond v0)) - Core.TypeRecord v0 -> Lists.concat (Lists.map (\ft -> collectTypeVariablesFromType (Core.fieldTypeType ft)) v0) - Core.TypeSet v0 -> collectTypeVariablesFromType v0 - Core.TypeUnion v0 -> Lists.concat (Lists.map (\ft -> collectTypeVariablesFromType (Core.fieldTypeType ft)) v0) - Core.TypeVariable v0 -> [ - v0] - Core.TypeWrap v0 -> collectTypeVariablesFromType v0 - _ -> [] - --- | Transform a type binding into a decoder binding -decodeBinding :: Context.Context -> Graph.Graph -> Core.Binding -> Either (Context.InContext Errors.DecodingError) Core.Binding -decodeBinding cx graph b = - Eithers.bind (Eithers.bimap (\_wc_e -> Context.InContext { - Context.inContextObject = _wc_e, - Context.inContextContext = cx}) (\_wc_a -> _wc_a) (Core_.type_ graph (Core.bindingTerm b))) (\typ -> Right (Core.Binding { - Core.bindingName = (decodeBindingName (Core.bindingName b)), - Core.bindingTerm = (decodeTypeNamed (Core.bindingName b) typ), - Core.bindingType = (Just (decoderTypeSchemeNamed (Core.bindingName b) typ))})) - --- | Generate a binding name for a decoder function from a type name -decodeBindingName :: Core.Name -> Core.Name -decodeBindingName n = - Logic.ifElse (Logic.not (Lists.null (Lists.tail (Strings.splitOn "." (Core.unName n))))) (Core.Name (Strings.intercalate "." (Lists.concat2 [ - "hydra", - "decode"] (Lists.concat2 (Lists.tail (Lists.init (Strings.splitOn "." (Core.unName n)))) [ - Formatting.decapitalize (Names.localNameOf n)])))) (Core.Name (Formatting.decapitalize (Names.localNameOf n))) - --- | Generate a decoder for an Either type -decodeEitherType :: Core.EitherType -> Core.Term -decodeEitherType et = - - let leftDecoder = decodeType (Core.eitherTypeLeft et) - rightDecoder = decodeType (Core.eitherTypeRight et) - in (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeEither")), - Core.applicationArgument = leftDecoder})), - Core.applicationArgument = rightDecoder})) - --- | Generate a decoder for a polymorphic (forall) type -decodeForallType :: Core.ForallType -> Core.Term -decodeForallType ft = - Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (decodeBindingName (Core.forallTypeParameter ft)), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (decodeType (Core.forallTypeBody ft))})) - --- | Generate a decoder for a list type -decodeListType :: Core.Type -> Core.Term -decodeListType elemType = - - let elemDecoder = decodeType elemType - in (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeList")), - Core.applicationArgument = elemDecoder})) - --- | Generate a decoder for a literal type -decodeLiteralType :: Core.LiteralType -> Core.Term -decodeLiteralType lt = - case lt of - Core.LiteralTypeBinary -> Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected binary literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "binary"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "b"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "b"))))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))})) - Core.LiteralTypeBoolean -> Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected boolean literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "boolean"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "b"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "b"))))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))})) - Core.LiteralTypeFloat v0 -> case v0 of - Core.FloatTypeBigfloat -> Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Strings.cat [ - "expected ", - "bigfloat", - " literal"])))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "float"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.FloatValue"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Strings.cat [ - "expected ", - "bigfloat", - " value"])))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "bigfloat"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "f"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "f"))))})))}]}))))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))})) - Core.FloatTypeFloat32 -> Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Strings.cat [ - "expected ", - "float32", - " literal"])))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "float"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.FloatValue"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Strings.cat [ - "expected ", - "float32", - " value"])))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "float32"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "f"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "f"))))})))}]}))))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))})) - Core.FloatTypeFloat64 -> Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Strings.cat [ - "expected ", - "float64", - " literal"])))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "float"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.FloatValue"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Strings.cat [ - "expected ", - "float64", - " value"])))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "float64"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "f"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "f"))))})))}]}))))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))})) - Core.LiteralTypeInteger v0 -> case v0 of - Core.IntegerTypeBigint -> Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Strings.cat [ - "expected ", - "bigint", - " literal"])))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Strings.cat [ - "expected ", - "bigint", - " value"])))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "bigint"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "i"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i"))))})))}]}))))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))})) - Core.IntegerTypeInt8 -> Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Strings.cat [ - "expected ", - "int8", - " literal"])))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Strings.cat [ - "expected ", - "int8", - " value"])))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "int8"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "i"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i"))))})))}]}))))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))})) - Core.IntegerTypeInt16 -> Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Strings.cat [ - "expected ", - "int16", - " literal"])))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Strings.cat [ - "expected ", - "int16", - " value"])))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "int16"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "i"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i"))))})))}]}))))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))})) - Core.IntegerTypeInt32 -> Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Strings.cat [ - "expected ", - "int32", - " literal"])))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Strings.cat [ - "expected ", - "int32", - " value"])))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "int32"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "i"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i"))))})))}]}))))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))})) - Core.IntegerTypeInt64 -> Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Strings.cat [ - "expected ", - "int64", - " literal"])))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Strings.cat [ - "expected ", - "int64", - " value"])))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "int64"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "i"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i"))))})))}]}))))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))})) - Core.IntegerTypeUint8 -> Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Strings.cat [ - "expected ", - "uint8", - " literal"])))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Strings.cat [ - "expected ", - "uint8", - " value"])))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "uint8"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "i"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i"))))})))}]}))))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))})) - Core.IntegerTypeUint16 -> Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Strings.cat [ - "expected ", - "uint16", - " literal"])))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Strings.cat [ - "expected ", - "uint16", - " value"])))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "uint16"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "i"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i"))))})))}]}))))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))})) - Core.IntegerTypeUint32 -> Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Strings.cat [ - "expected ", - "uint32", - " literal"])))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Strings.cat [ - "expected ", - "uint32", - " value"])))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "uint32"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "i"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i"))))})))}]}))))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))})) - Core.IntegerTypeUint64 -> Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Strings.cat [ - "expected ", - "uint64", - " literal"])))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Strings.cat [ - "expected ", - "uint64", - " value"])))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "uint64"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "i"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i"))))})))}]}))))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))})) - Core.LiteralTypeString -> Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "s"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))})) - --- | Generate a decoder for a map type -decodeMapType :: Core.MapType -> Core.Term -decodeMapType mt = - - let keyDecoder = decodeType (Core.mapTypeKeys mt) - valDecoder = decodeType (Core.mapTypeValues mt) - in (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeMap")), - Core.applicationArgument = keyDecoder})), - Core.applicationArgument = valDecoder})) - --- | Generate a decoder for an optional type -decodeMaybeType :: Core.Type -> Core.Term -decodeMaybeType elemType = - - let elemDecoder = decodeType elemType - in (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeMaybe")), - Core.applicationArgument = elemDecoder})) - --- | Transform a type module into a decoder module -decodeModule :: Context.Context -> Graph.Graph -> Module.Module -> Either (Context.InContext Errors.Error) (Maybe Module.Module) -decodeModule cx graph mod = - Eithers.bind (filterTypeBindings cx graph (Maybes.cat (Lists.map (\d -> case d of - Module.DefinitionType v0 -> Just (Annotations.typeElement (Module.typeDefinitionName v0) (Module.typeDefinitionType v0)) - _ -> Nothing) (Module.moduleDefinitions mod)))) (\typeBindings -> Logic.ifElse (Lists.null typeBindings) (Right Nothing) (Eithers.bind (Eithers.mapList (\b -> Eithers.bimap (\ic -> Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Errors.unDecodingError (Context.inContextObject ic)))), - Context.inContextContext = (Context.inContextContext ic)}) (\x -> x) (decodeBinding cx graph b)) typeBindings) (\decodedBindings -> - let decodedTypeDeps = Lists.map decodeNamespace (Module.moduleTypeDependencies mod) - decodedTermDeps = Lists.map decodeNamespace (Module.moduleTermDependencies mod) - allDecodedDeps = Lists.nub (Lists.concat2 decodedTypeDeps decodedTermDeps) - in (Right (Just (Module.Module { - Module.moduleNamespace = (decodeNamespace (Module.moduleNamespace mod)), - Module.moduleDefinitions = (Lists.map (\b -> Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.bindingName b), - Module.termDefinitionTerm = (Core.bindingTerm b), - Module.termDefinitionType = (Core.bindingType b)})) decodedBindings), - Module.moduleTermDependencies = (Lists.concat2 [ - Module.Namespace "hydra.extract.helpers", - (Module.Namespace "hydra.lexical"), - (Module.Namespace "hydra.rewriting")] allDecodedDeps), - Module.moduleTypeDependencies = [ - Module.moduleNamespace mod, - (Module.Namespace "hydra.util")], - Module.moduleDescription = (Just (Strings.cat [ - "Term decoders for ", - (Module.unNamespace (Module.moduleNamespace mod))]))})))))) - --- | Generate a decoder module namespace from a source module namespace -decodeNamespace :: Module.Namespace -> Module.Namespace -decodeNamespace ns = - Module.Namespace (Strings.cat [ - "hydra.decode.", - (Strings.intercalate "." (Lists.tail (Strings.splitOn "." (Module.unNamespace ns))))]) - --- | Generate a decoder for a pair type -decodePairType :: Core.PairType -> Core.Term -decodePairType pt = - - let firstDecoder = decodeType (Core.pairTypeFirst pt) - secondDecoder = decodeType (Core.pairTypeSecond pt) - in (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodePair")), - Core.applicationArgument = firstDecoder})), - Core.applicationArgument = secondDecoder})) - --- | Generate a decoder for a record type -decodeRecordType :: [Core.FieldType] -> Core.Term -decodeRecordType rt = decodeRecordTypeImpl (Core.Name "unknown") rt - --- | Generate a decoder for a record type with a type name -decodeRecordTypeImpl :: Core.Name -> [Core.FieldType] -> Core.Term -decodeRecordTypeImpl tname rt = - - let decodeFieldTerm = - \ft -> Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString (Core.unName (Core.fieldTypeName ft))))})), - Core.applicationArgument = (decodeType (Core.fieldTypeType ft))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}) - localVarName = - \ft -> Core.Name (Strings.cat [ - "field_", - (Core.unName (Core.fieldTypeName ft))]) - toFieldLambda = - \ft -> \body -> Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (localVarName ft), - Core.lambdaDomain = Nothing, - Core.lambdaBody = body})) - decodeBody = - Lists.foldl (\acc -> \ft -> Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (decodeFieldTerm ft)})), - Core.applicationArgument = (toFieldLambda ft acc)})) (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = tname, - Core.recordFields = (Lists.map (\ft -> Core.Field { - Core.fieldName = (Core.fieldTypeName ft), - Core.fieldTerm = (Core.TermVariable (localVarName ft))}) rt)})))) (Lists.reverse rt) - in (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = decodeBody}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))) - --- | Generate a decoder for a record type with element name -decodeRecordTypeNamed :: Core.Name -> [Core.FieldType] -> Core.Term -decodeRecordTypeNamed ename rt = decodeRecordTypeImpl ename rt - --- | Generate a decoder for a set type -decodeSetType :: Core.Type -> Core.Term -decodeSetType elemType = - - let elemDecoder = decodeType elemType - in (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeSet")), - Core.applicationArgument = elemDecoder})) - --- | Generate a decoder term for a Type -decodeType :: Core.Type -> Core.Term -decodeType typ = - case typ of - Core.TypeAnnotated v0 -> decodeType (Core.annotatedTypeBody v0) - Core.TypeApplication v0 -> Core.TermApplication (Core.Application { - Core.applicationFunction = (decodeType (Core.applicationTypeFunction v0)), - Core.applicationArgument = (decodeType (Core.applicationTypeArgument v0))}) - Core.TypeEither v0 -> decodeEitherType v0 - Core.TypeForall v0 -> decodeForallType v0 - Core.TypeList v0 -> decodeListType v0 - Core.TypeLiteral v0 -> decodeLiteralType v0 - Core.TypeMap v0 -> decodeMapType v0 - Core.TypeMaybe v0 -> decodeMaybeType v0 - Core.TypePair v0 -> decodePairType v0 - Core.TypeRecord v0 -> decodeRecordType v0 - Core.TypeSet v0 -> decodeSetType v0 - Core.TypeUnion v0 -> decodeUnionType v0 - Core.TypeUnit -> decodeUnitType - Core.TypeVoid -> decodeUnitType - Core.TypeWrap v0 -> decodeWrappedType v0 - Core.TypeVariable v0 -> Core.TermVariable (decodeBindingName v0) - _ -> Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unsupported type variant"))}))))})))})) - --- | Generate a decoder term for a Type, with element name for nominal types -decodeTypeNamed :: Core.Name -> Core.Type -> Core.Term -decodeTypeNamed ename typ = - case typ of - Core.TypeAnnotated v0 -> decodeTypeNamed ename (Core.annotatedTypeBody v0) - Core.TypeApplication v0 -> Core.TermApplication (Core.Application { - Core.applicationFunction = (decodeType (Core.applicationTypeFunction v0)), - Core.applicationArgument = (decodeType (Core.applicationTypeArgument v0))}) - Core.TypeEither v0 -> decodeEitherType v0 - Core.TypeForall v0 -> Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (decodeBindingName (Core.forallTypeParameter v0)), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (decodeTypeNamed ename (Core.forallTypeBody v0))})) - Core.TypeList v0 -> decodeListType v0 - Core.TypeLiteral v0 -> decodeLiteralType v0 - Core.TypeMap v0 -> decodeMapType v0 - Core.TypeMaybe v0 -> decodeMaybeType v0 - Core.TypePair v0 -> decodePairType v0 - Core.TypeRecord v0 -> decodeRecordTypeNamed ename v0 - Core.TypeSet v0 -> decodeSetType v0 - Core.TypeUnion v0 -> decodeUnionTypeNamed ename v0 - Core.TypeUnit -> decodeUnitType - Core.TypeVoid -> decodeUnitType - Core.TypeWrap v0 -> decodeWrappedTypeNamed ename v0 - Core.TypeVariable v0 -> Core.TermVariable (decodeBindingName v0) - _ -> Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unsupported type variant"))}))))})))})) - --- | Generate a decoder for a union type -decodeUnionType :: [Core.FieldType] -> Core.Term -decodeUnionType rt = decodeUnionTypeNamed (Core.Name "unknown") rt - --- | Generate a decoder for a union type with the given element name -decodeUnionTypeNamed :: Core.Name -> [Core.FieldType] -> Core.Term -decodeUnionTypeNamed ename rt = - - let toVariantPair = - \ft -> Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Core.unName (Core.fieldTypeName ft))))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = ename, - Core.injectionField = Core.Field { - Core.fieldName = (Core.fieldTypeName ft), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (decodeType (Core.fieldTypeType ft)), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))) - in (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "union"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "inj"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "field"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionField = (Core.Name "field")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionField = (Core.Name "term")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.fromList"))), - Core.applicationArgument = (Core.TermList (Lists.map toVariantPair rt))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maybes.maybe"))), - Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.cat"))), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.core.Name")))), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "f"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "f")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.lookup"))), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))) - --- | Generate a decoder for the unit type -decodeUnitType :: Core.Term -decodeUnitType = Core.TermVariable (Core.Name "hydra.extract.helpers.decodeUnit") - --- | Generate a decoder for a wrapped type -decodeWrappedType :: Core.Type -> Core.Term -decodeWrappedType wt = decodeWrappedTypeNamed (Core.Name "unknown") wt - --- | Generate a decoder for a wrapped type with the given element name -decodeWrappedTypeNamed :: Core.Name -> Core.Type -> Core.Term -decodeWrappedTypeNamed ename wt = - - let bodyDecoder = decodeType wt - in (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected wrapped type"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "wrap"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "wrappedTerm"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "b"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = ename, - Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = bodyDecoder, - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.projectionField = (Core.Name "body")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "wrappedTerm"))}))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))) - --- | Get full result type for decoder -decoderFullResultType :: Core.Type -> Core.Type -decoderFullResultType typ = - case typ of - Core.TypeAnnotated v0 -> decoderFullResultType (Core.annotatedTypeBody v0) - Core.TypeApplication v0 -> Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (decoderFullResultType (Core.applicationTypeFunction v0)), - Core.applicationTypeArgument = (Core.applicationTypeArgument v0)}) - Core.TypeEither v0 -> Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (decoderFullResultType (Core.eitherTypeLeft v0)), - Core.eitherTypeRight = (decoderFullResultType (Core.eitherTypeRight v0))}) - Core.TypeForall v0 -> Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (decoderFullResultType (Core.forallTypeBody v0)), - Core.applicationTypeArgument = (Core.TypeVariable (Core.forallTypeParameter v0))}) - Core.TypeList v0 -> Core.TypeList (decoderFullResultType v0) - Core.TypeLiteral _ -> Core.TypeVariable (Core.Name "hydra.core.Literal") - Core.TypeMap v0 -> Core.TypeMap (Core.MapType { - Core.mapTypeKeys = (decoderFullResultType (Core.mapTypeKeys v0)), - Core.mapTypeValues = (decoderFullResultType (Core.mapTypeValues v0))}) - Core.TypeMaybe v0 -> Core.TypeMaybe (decoderFullResultType v0) - Core.TypePair v0 -> Core.TypePair (Core.PairType { - Core.pairTypeFirst = (decoderFullResultType (Core.pairTypeFirst v0)), - Core.pairTypeSecond = (decoderFullResultType (Core.pairTypeSecond v0))}) - Core.TypeRecord _ -> Core.TypeVariable (Core.Name "hydra.core.Term") - Core.TypeSet v0 -> Core.TypeSet (decoderFullResultType v0) - Core.TypeUnion _ -> Core.TypeVariable (Core.Name "hydra.core.Term") - Core.TypeUnit -> Core.TypeUnit - Core.TypeVariable v0 -> Core.TypeVariable v0 - Core.TypeVoid -> Core.TypeVoid - Core.TypeWrap _ -> Core.TypeVariable (Core.Name "hydra.core.Term") - _ -> Core.TypeVariable (Core.Name "hydra.core.Term") - --- | Get full result type for decoder with element name -decoderFullResultTypeNamed :: Core.Name -> Core.Type -> Core.Type -decoderFullResultTypeNamed ename typ = - case typ of - Core.TypeAnnotated v0 -> decoderFullResultTypeNamed ename (Core.annotatedTypeBody v0) - Core.TypeForall v0 -> Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (decoderFullResultTypeNamed ename (Core.forallTypeBody v0)), - Core.applicationTypeArgument = (Core.TypeVariable (Core.forallTypeParameter v0))}) - Core.TypeRecord _ -> Core.TypeVariable ename - Core.TypeUnion _ -> Core.TypeVariable ename - Core.TypeWrap _ -> Core.TypeVariable ename - Core.TypeApplication v0 -> Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (decoderFullResultType (Core.applicationTypeFunction v0)), - Core.applicationTypeArgument = (Core.applicationTypeArgument v0)}) - Core.TypeEither v0 -> Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (decoderFullResultType (Core.eitherTypeLeft v0)), - Core.eitherTypeRight = (decoderFullResultType (Core.eitherTypeRight v0))}) - Core.TypeList v0 -> Core.TypeList (decoderFullResultType v0) - Core.TypeLiteral _ -> Core.TypeVariable (Core.Name "hydra.core.Literal") - Core.TypeMap v0 -> Core.TypeMap (Core.MapType { - Core.mapTypeKeys = (decoderFullResultType (Core.mapTypeKeys v0)), - Core.mapTypeValues = (decoderFullResultType (Core.mapTypeValues v0))}) - Core.TypeMaybe v0 -> Core.TypeMaybe (decoderFullResultType v0) - Core.TypePair v0 -> Core.TypePair (Core.PairType { - Core.pairTypeFirst = (decoderFullResultType (Core.pairTypeFirst v0)), - Core.pairTypeSecond = (decoderFullResultType (Core.pairTypeSecond v0))}) - Core.TypeSet v0 -> Core.TypeSet (decoderFullResultType v0) - Core.TypeUnit -> Core.TypeUnit - Core.TypeVariable v0 -> Core.TypeVariable v0 - Core.TypeVoid -> Core.TypeVoid - _ -> Core.TypeVariable (Core.Name "hydra.core.Term") - --- | Compute the result type name for a decoder -decoderResultType :: Core.Type -> Core.Name -decoderResultType typ = - case typ of - Core.TypeAnnotated v0 -> decoderResultType (Core.annotatedTypeBody v0) - Core.TypeApplication v0 -> decoderResultType (Core.applicationTypeFunction v0) - Core.TypeForall v0 -> decoderResultType (Core.forallTypeBody v0) - Core.TypeLiteral _ -> Core.Name "hydra.core.Literal" - Core.TypeRecord _ -> Core.Name "hydra.core.Term" - Core.TypeUnion _ -> Core.Name "hydra.core.Term" - Core.TypeWrap _ -> Core.Name "hydra.core.Term" - _ -> Core.Name "hydra.core.Term" - --- | Build decoder function type -decoderType :: Core.Type -> Core.Type -decoderType typ = - - let resultType = decoderFullResultType typ - baseType = - Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = resultType}))}))}) - in (prependForallDecoders baseType typ) - --- | Build decoder function type with element name -decoderTypeNamed :: Core.Name -> Core.Type -> Core.Type -decoderTypeNamed ename typ = - - let resultType = decoderFullResultTypeNamed ename typ - baseType = - Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = resultType}))}))}) - in (prependForallDecoders baseType typ) - --- | Build type scheme for a decoder function -decoderTypeScheme :: Core.Type -> Core.TypeScheme -decoderTypeScheme typ = - - let typeVars = collectTypeVariables typ - allOrdVars = collectOrdConstrainedVariables typ - ordVars = Lists.filter (\v -> Lists.elem v typeVars) allOrdVars - constraints = - Logic.ifElse (Lists.null ordVars) Nothing (Just (Maps.fromList (Lists.map (\v -> (v, Core.TypeVariableMetadata { - Core.typeVariableMetadataClasses = (Sets.singleton (Core.Name "ordering"))})) ordVars))) - in Core.TypeScheme { - Core.typeSchemeVariables = typeVars, - Core.typeSchemeType = (decoderType typ), - Core.typeSchemeConstraints = constraints} - --- | Build type scheme for a decoder function with element name -decoderTypeSchemeNamed :: Core.Name -> Core.Type -> Core.TypeScheme -decoderTypeSchemeNamed ename typ = - - let typeVars = collectTypeVariables typ - allOrdVars = collectOrdConstrainedVariables typ - ordVars = Lists.filter (\v -> Lists.elem v typeVars) allOrdVars - constraints = - Logic.ifElse (Lists.null ordVars) Nothing (Just (Maps.fromList (Lists.map (\v -> (v, Core.TypeVariableMetadata { - Core.typeVariableMetadataClasses = (Sets.singleton (Core.Name "ordering"))})) ordVars))) - in Core.TypeScheme { - Core.typeSchemeVariables = typeVars, - Core.typeSchemeType = (decoderTypeNamed ename typ), - Core.typeSchemeConstraints = constraints} - --- | Filter bindings to only decodable type definitions -filterTypeBindings :: Context.Context -> Graph.Graph -> [Core.Binding] -> Either (Context.InContext Errors.Error) [Core.Binding] -filterTypeBindings cx graph bindings = - Eithers.map Maybes.cat (Eithers.mapList (isDecodableBinding cx graph) (Lists.filter Annotations.isNativeType bindings)) - --- | Check if a binding is decodable (serializable type) -isDecodableBinding :: Context.Context -> Graph.Graph -> Core.Binding -> Either (Context.InContext Errors.Error) (Maybe Core.Binding) -isDecodableBinding cx graph b = - Eithers.bind (Schemas.isSerializableByName cx graph (Core.bindingName b)) (\serializable -> Right (Logic.ifElse serializable (Just b) Nothing)) - --- | Prepend decoder types for forall parameters to base type -prependForallDecoders :: Core.Type -> Core.Type -> Core.Type -prependForallDecoders baseType typ = - case typ of - Core.TypeAnnotated v0 -> prependForallDecoders baseType (Core.annotatedTypeBody v0) - Core.TypeForall v0 -> Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.forallTypeParameter v0))}))}))})), - Core.functionTypeCodomain = (prependForallDecoders baseType (Core.forallTypeBody v0))}) - _ -> baseType diff --git a/src/gen-main/haskell/Hydra/Dsl/Ast.hs b/src/gen-main/haskell/Hydra/Dsl/Ast.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Dsl/Ast.hs +++ /dev/null @@ -1,901 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | DSL functions for hydra.ast - -module Hydra.Dsl.Ast where - -import qualified Hydra.Ast as Ast -import qualified Hydra.Core as Core -import qualified Hydra.Phantoms as Phantoms -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -associativityBoth :: Phantoms.TTerm Ast.Associativity -associativityBoth = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.Associativity"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "both"), - Core.fieldTerm = Core.TermUnit}})) - -associativityLeft :: Phantoms.TTerm Ast.Associativity -associativityLeft = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.Associativity"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "left"), - Core.fieldTerm = Core.TermUnit}})) - -associativityNone :: Phantoms.TTerm Ast.Associativity -associativityNone = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.Associativity"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "none"), - Core.fieldTerm = Core.TermUnit}})) - -associativityRight :: Phantoms.TTerm Ast.Associativity -associativityRight = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.Associativity"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "right"), - Core.fieldTerm = Core.TermUnit}})) - -blockStyle :: Phantoms.TTerm (Maybe String) -> Phantoms.TTerm Bool -> Phantoms.TTerm Bool -> Phantoms.TTerm Ast.BlockStyle -blockStyle indent newlineBeforeContent newlineAfterContent = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ast.BlockStyle"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "indent"), - Core.fieldTerm = (Phantoms.unTTerm indent)}, - Core.Field { - Core.fieldName = (Core.Name "newlineBeforeContent"), - Core.fieldTerm = (Phantoms.unTTerm newlineBeforeContent)}, - Core.Field { - Core.fieldName = (Core.Name "newlineAfterContent"), - Core.fieldTerm = (Phantoms.unTTerm newlineAfterContent)}]})) - -blockStyleIndent :: Phantoms.TTerm Ast.BlockStyle -> Phantoms.TTerm (Maybe String) -blockStyleIndent x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.BlockStyle"), - Core.projectionField = (Core.Name "indent")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -blockStyleNewlineAfterContent :: Phantoms.TTerm Ast.BlockStyle -> Phantoms.TTerm Bool -blockStyleNewlineAfterContent x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.BlockStyle"), - Core.projectionField = (Core.Name "newlineAfterContent")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -blockStyleNewlineBeforeContent :: Phantoms.TTerm Ast.BlockStyle -> Phantoms.TTerm Bool -blockStyleNewlineBeforeContent x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.BlockStyle"), - Core.projectionField = (Core.Name "newlineBeforeContent")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -blockStyleWithIndent :: Phantoms.TTerm Ast.BlockStyle -> Phantoms.TTerm (Maybe String) -> Phantoms.TTerm Ast.BlockStyle -blockStyleWithIndent original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ast.BlockStyle"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "indent"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "newlineBeforeContent"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.BlockStyle"), - Core.projectionField = (Core.Name "newlineBeforeContent")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "newlineAfterContent"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.BlockStyle"), - Core.projectionField = (Core.Name "newlineAfterContent")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -blockStyleWithNewlineAfterContent :: Phantoms.TTerm Ast.BlockStyle -> Phantoms.TTerm Bool -> Phantoms.TTerm Ast.BlockStyle -blockStyleWithNewlineAfterContent original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ast.BlockStyle"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "indent"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.BlockStyle"), - Core.projectionField = (Core.Name "indent")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "newlineBeforeContent"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.BlockStyle"), - Core.projectionField = (Core.Name "newlineBeforeContent")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "newlineAfterContent"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -blockStyleWithNewlineBeforeContent :: Phantoms.TTerm Ast.BlockStyle -> Phantoms.TTerm Bool -> Phantoms.TTerm Ast.BlockStyle -blockStyleWithNewlineBeforeContent original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ast.BlockStyle"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "indent"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.BlockStyle"), - Core.projectionField = (Core.Name "indent")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "newlineBeforeContent"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "newlineAfterContent"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.BlockStyle"), - Core.projectionField = (Core.Name "newlineAfterContent")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -bracketExpr :: Phantoms.TTerm Ast.Brackets -> Phantoms.TTerm Ast.Expr -> Phantoms.TTerm Ast.BlockStyle -> Phantoms.TTerm Ast.BracketExpr -bracketExpr brackets enclosed style = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ast.BracketExpr"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "brackets"), - Core.fieldTerm = (Phantoms.unTTerm brackets)}, - Core.Field { - Core.fieldName = (Core.Name "enclosed"), - Core.fieldTerm = (Phantoms.unTTerm enclosed)}, - Core.Field { - Core.fieldName = (Core.Name "style"), - Core.fieldTerm = (Phantoms.unTTerm style)}]})) - -bracketExprBrackets :: Phantoms.TTerm Ast.BracketExpr -> Phantoms.TTerm Ast.Brackets -bracketExprBrackets x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.BracketExpr"), - Core.projectionField = (Core.Name "brackets")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -bracketExprEnclosed :: Phantoms.TTerm Ast.BracketExpr -> Phantoms.TTerm Ast.Expr -bracketExprEnclosed x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.BracketExpr"), - Core.projectionField = (Core.Name "enclosed")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -bracketExprStyle :: Phantoms.TTerm Ast.BracketExpr -> Phantoms.TTerm Ast.BlockStyle -bracketExprStyle x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.BracketExpr"), - Core.projectionField = (Core.Name "style")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -bracketExprWithBrackets :: Phantoms.TTerm Ast.BracketExpr -> Phantoms.TTerm Ast.Brackets -> Phantoms.TTerm Ast.BracketExpr -bracketExprWithBrackets original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ast.BracketExpr"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "brackets"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "enclosed"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.BracketExpr"), - Core.projectionField = (Core.Name "enclosed")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "style"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.BracketExpr"), - Core.projectionField = (Core.Name "style")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -bracketExprWithEnclosed :: Phantoms.TTerm Ast.BracketExpr -> Phantoms.TTerm Ast.Expr -> Phantoms.TTerm Ast.BracketExpr -bracketExprWithEnclosed original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ast.BracketExpr"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "brackets"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.BracketExpr"), - Core.projectionField = (Core.Name "brackets")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "enclosed"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "style"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.BracketExpr"), - Core.projectionField = (Core.Name "style")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -bracketExprWithStyle :: Phantoms.TTerm Ast.BracketExpr -> Phantoms.TTerm Ast.BlockStyle -> Phantoms.TTerm Ast.BracketExpr -bracketExprWithStyle original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ast.BracketExpr"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "brackets"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.BracketExpr"), - Core.projectionField = (Core.Name "brackets")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "enclosed"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.BracketExpr"), - Core.projectionField = (Core.Name "enclosed")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "style"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -brackets :: Phantoms.TTerm Ast.Symbol -> Phantoms.TTerm Ast.Symbol -> Phantoms.TTerm Ast.Brackets -brackets open close = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ast.Brackets"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "open"), - Core.fieldTerm = (Phantoms.unTTerm open)}, - Core.Field { - Core.fieldName = (Core.Name "close"), - Core.fieldTerm = (Phantoms.unTTerm close)}]})) - -bracketsClose :: Phantoms.TTerm Ast.Brackets -> Phantoms.TTerm Ast.Symbol -bracketsClose x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.Brackets"), - Core.projectionField = (Core.Name "close")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -bracketsOpen :: Phantoms.TTerm Ast.Brackets -> Phantoms.TTerm Ast.Symbol -bracketsOpen x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.Brackets"), - Core.projectionField = (Core.Name "open")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -bracketsWithClose :: Phantoms.TTerm Ast.Brackets -> Phantoms.TTerm Ast.Symbol -> Phantoms.TTerm Ast.Brackets -bracketsWithClose original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ast.Brackets"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "open"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.Brackets"), - Core.projectionField = (Core.Name "open")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "close"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -bracketsWithOpen :: Phantoms.TTerm Ast.Brackets -> Phantoms.TTerm Ast.Symbol -> Phantoms.TTerm Ast.Brackets -bracketsWithOpen original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ast.Brackets"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "open"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "close"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.Brackets"), - Core.projectionField = (Core.Name "close")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -exprBrackets :: Phantoms.TTerm Ast.BracketExpr -> Phantoms.TTerm Ast.Expr -exprBrackets x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.Expr"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "brackets"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -exprConst :: Phantoms.TTerm Ast.Symbol -> Phantoms.TTerm Ast.Expr -exprConst x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.Expr"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "const"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -exprIndent :: Phantoms.TTerm Ast.IndentedExpression -> Phantoms.TTerm Ast.Expr -exprIndent x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.Expr"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "indent"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -exprOp :: Phantoms.TTerm Ast.OpExpr -> Phantoms.TTerm Ast.Expr -exprOp x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.Expr"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "op"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -exprSeq :: Phantoms.TTerm Ast.SeqExpr -> Phantoms.TTerm Ast.Expr -exprSeq x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.Expr"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "seq"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -indentStyleAllLines :: Phantoms.TTerm String -> Phantoms.TTerm Ast.IndentStyle -indentStyleAllLines x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.IndentStyle"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "allLines"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -indentStyleSubsequentLines :: Phantoms.TTerm String -> Phantoms.TTerm Ast.IndentStyle -indentStyleSubsequentLines x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.IndentStyle"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "subsequentLines"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -indentedExpression :: Phantoms.TTerm Ast.IndentStyle -> Phantoms.TTerm Ast.Expr -> Phantoms.TTerm Ast.IndentedExpression -indentedExpression style expr = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ast.IndentedExpression"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "style"), - Core.fieldTerm = (Phantoms.unTTerm style)}, - Core.Field { - Core.fieldName = (Core.Name "expr"), - Core.fieldTerm = (Phantoms.unTTerm expr)}]})) - -indentedExpressionExpr :: Phantoms.TTerm Ast.IndentedExpression -> Phantoms.TTerm Ast.Expr -indentedExpressionExpr x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.IndentedExpression"), - Core.projectionField = (Core.Name "expr")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -indentedExpressionStyle :: Phantoms.TTerm Ast.IndentedExpression -> Phantoms.TTerm Ast.IndentStyle -indentedExpressionStyle x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.IndentedExpression"), - Core.projectionField = (Core.Name "style")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -indentedExpressionWithExpr :: Phantoms.TTerm Ast.IndentedExpression -> Phantoms.TTerm Ast.Expr -> Phantoms.TTerm Ast.IndentedExpression -indentedExpressionWithExpr original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ast.IndentedExpression"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "style"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.IndentedExpression"), - Core.projectionField = (Core.Name "style")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "expr"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -indentedExpressionWithStyle :: Phantoms.TTerm Ast.IndentedExpression -> Phantoms.TTerm Ast.IndentStyle -> Phantoms.TTerm Ast.IndentedExpression -indentedExpressionWithStyle original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ast.IndentedExpression"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "style"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "expr"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.IndentedExpression"), - Core.projectionField = (Core.Name "expr")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -op :: Phantoms.TTerm Ast.Symbol -> Phantoms.TTerm Ast.Padding -> Phantoms.TTerm Ast.Precedence -> Phantoms.TTerm Ast.Associativity -> Phantoms.TTerm Ast.Op -op symbol padding precedence associativity = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ast.Op"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "symbol"), - Core.fieldTerm = (Phantoms.unTTerm symbol)}, - Core.Field { - Core.fieldName = (Core.Name "padding"), - Core.fieldTerm = (Phantoms.unTTerm padding)}, - Core.Field { - Core.fieldName = (Core.Name "precedence"), - Core.fieldTerm = (Phantoms.unTTerm precedence)}, - Core.Field { - Core.fieldName = (Core.Name "associativity"), - Core.fieldTerm = (Phantoms.unTTerm associativity)}]})) - -opAssociativity :: Phantoms.TTerm Ast.Op -> Phantoms.TTerm Ast.Associativity -opAssociativity x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.Op"), - Core.projectionField = (Core.Name "associativity")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -opExpr :: Phantoms.TTerm Ast.Op -> Phantoms.TTerm Ast.Expr -> Phantoms.TTerm Ast.Expr -> Phantoms.TTerm Ast.OpExpr -opExpr op lhs rhs = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ast.OpExpr"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "op"), - Core.fieldTerm = (Phantoms.unTTerm op)}, - Core.Field { - Core.fieldName = (Core.Name "lhs"), - Core.fieldTerm = (Phantoms.unTTerm lhs)}, - Core.Field { - Core.fieldName = (Core.Name "rhs"), - Core.fieldTerm = (Phantoms.unTTerm rhs)}]})) - -opExprLhs :: Phantoms.TTerm Ast.OpExpr -> Phantoms.TTerm Ast.Expr -opExprLhs x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.OpExpr"), - Core.projectionField = (Core.Name "lhs")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -opExprOp :: Phantoms.TTerm Ast.OpExpr -> Phantoms.TTerm Ast.Op -opExprOp x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.OpExpr"), - Core.projectionField = (Core.Name "op")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -opExprRhs :: Phantoms.TTerm Ast.OpExpr -> Phantoms.TTerm Ast.Expr -opExprRhs x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.OpExpr"), - Core.projectionField = (Core.Name "rhs")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -opExprWithLhs :: Phantoms.TTerm Ast.OpExpr -> Phantoms.TTerm Ast.Expr -> Phantoms.TTerm Ast.OpExpr -opExprWithLhs original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ast.OpExpr"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "op"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.OpExpr"), - Core.projectionField = (Core.Name "op")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "lhs"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "rhs"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.OpExpr"), - Core.projectionField = (Core.Name "rhs")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -opExprWithOp :: Phantoms.TTerm Ast.OpExpr -> Phantoms.TTerm Ast.Op -> Phantoms.TTerm Ast.OpExpr -opExprWithOp original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ast.OpExpr"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "op"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "lhs"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.OpExpr"), - Core.projectionField = (Core.Name "lhs")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "rhs"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.OpExpr"), - Core.projectionField = (Core.Name "rhs")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -opExprWithRhs :: Phantoms.TTerm Ast.OpExpr -> Phantoms.TTerm Ast.Expr -> Phantoms.TTerm Ast.OpExpr -opExprWithRhs original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ast.OpExpr"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "op"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.OpExpr"), - Core.projectionField = (Core.Name "op")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "lhs"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.OpExpr"), - Core.projectionField = (Core.Name "lhs")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "rhs"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -opPadding :: Phantoms.TTerm Ast.Op -> Phantoms.TTerm Ast.Padding -opPadding x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.Op"), - Core.projectionField = (Core.Name "padding")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -opPrecedence :: Phantoms.TTerm Ast.Op -> Phantoms.TTerm Ast.Precedence -opPrecedence x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.Op"), - Core.projectionField = (Core.Name "precedence")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -opSymbol :: Phantoms.TTerm Ast.Op -> Phantoms.TTerm Ast.Symbol -opSymbol x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.Op"), - Core.projectionField = (Core.Name "symbol")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -opWithAssociativity :: Phantoms.TTerm Ast.Op -> Phantoms.TTerm Ast.Associativity -> Phantoms.TTerm Ast.Op -opWithAssociativity original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ast.Op"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "symbol"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.Op"), - Core.projectionField = (Core.Name "symbol")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "padding"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.Op"), - Core.projectionField = (Core.Name "padding")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "precedence"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.Op"), - Core.projectionField = (Core.Name "precedence")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "associativity"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -opWithPadding :: Phantoms.TTerm Ast.Op -> Phantoms.TTerm Ast.Padding -> Phantoms.TTerm Ast.Op -opWithPadding original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ast.Op"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "symbol"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.Op"), - Core.projectionField = (Core.Name "symbol")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "padding"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "precedence"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.Op"), - Core.projectionField = (Core.Name "precedence")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "associativity"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.Op"), - Core.projectionField = (Core.Name "associativity")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -opWithPrecedence :: Phantoms.TTerm Ast.Op -> Phantoms.TTerm Ast.Precedence -> Phantoms.TTerm Ast.Op -opWithPrecedence original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ast.Op"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "symbol"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.Op"), - Core.projectionField = (Core.Name "symbol")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "padding"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.Op"), - Core.projectionField = (Core.Name "padding")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "precedence"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "associativity"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.Op"), - Core.projectionField = (Core.Name "associativity")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -opWithSymbol :: Phantoms.TTerm Ast.Op -> Phantoms.TTerm Ast.Symbol -> Phantoms.TTerm Ast.Op -opWithSymbol original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ast.Op"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "symbol"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "padding"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.Op"), - Core.projectionField = (Core.Name "padding")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "precedence"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.Op"), - Core.projectionField = (Core.Name "precedence")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "associativity"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.Op"), - Core.projectionField = (Core.Name "associativity")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -padding :: Phantoms.TTerm Ast.Ws -> Phantoms.TTerm Ast.Ws -> Phantoms.TTerm Ast.Padding -padding left right = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ast.Padding"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "left"), - Core.fieldTerm = (Phantoms.unTTerm left)}, - Core.Field { - Core.fieldName = (Core.Name "right"), - Core.fieldTerm = (Phantoms.unTTerm right)}]})) - -paddingLeft :: Phantoms.TTerm Ast.Padding -> Phantoms.TTerm Ast.Ws -paddingLeft x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.Padding"), - Core.projectionField = (Core.Name "left")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -paddingRight :: Phantoms.TTerm Ast.Padding -> Phantoms.TTerm Ast.Ws -paddingRight x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.Padding"), - Core.projectionField = (Core.Name "right")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -paddingWithLeft :: Phantoms.TTerm Ast.Padding -> Phantoms.TTerm Ast.Ws -> Phantoms.TTerm Ast.Padding -paddingWithLeft original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ast.Padding"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "left"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "right"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.Padding"), - Core.projectionField = (Core.Name "right")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -paddingWithRight :: Phantoms.TTerm Ast.Padding -> Phantoms.TTerm Ast.Ws -> Phantoms.TTerm Ast.Padding -paddingWithRight original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ast.Padding"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "left"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.Padding"), - Core.projectionField = (Core.Name "left")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "right"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -precedence :: Phantoms.TTerm Int -> Phantoms.TTerm Ast.Precedence -precedence x = - Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.ast.Precedence"), - Core.wrappedTermBody = (Phantoms.unTTerm x)})) - -seqExpr :: Phantoms.TTerm Ast.Op -> Phantoms.TTerm [Ast.Expr] -> Phantoms.TTerm Ast.SeqExpr -seqExpr op elements = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ast.SeqExpr"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "op"), - Core.fieldTerm = (Phantoms.unTTerm op)}, - Core.Field { - Core.fieldName = (Core.Name "elements"), - Core.fieldTerm = (Phantoms.unTTerm elements)}]})) - -seqExprElements :: Phantoms.TTerm Ast.SeqExpr -> Phantoms.TTerm [Ast.Expr] -seqExprElements x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.SeqExpr"), - Core.projectionField = (Core.Name "elements")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -seqExprOp :: Phantoms.TTerm Ast.SeqExpr -> Phantoms.TTerm Ast.Op -seqExprOp x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.SeqExpr"), - Core.projectionField = (Core.Name "op")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -seqExprWithElements :: Phantoms.TTerm Ast.SeqExpr -> Phantoms.TTerm [Ast.Expr] -> Phantoms.TTerm Ast.SeqExpr -seqExprWithElements original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ast.SeqExpr"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "op"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.SeqExpr"), - Core.projectionField = (Core.Name "op")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "elements"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -seqExprWithOp :: Phantoms.TTerm Ast.SeqExpr -> Phantoms.TTerm Ast.Op -> Phantoms.TTerm Ast.SeqExpr -seqExprWithOp original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ast.SeqExpr"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "op"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "elements"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ast.SeqExpr"), - Core.projectionField = (Core.Name "elements")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -symbol :: Phantoms.TTerm String -> Phantoms.TTerm Ast.Symbol -symbol x = - Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.ast.Symbol"), - Core.wrappedTermBody = (Phantoms.unTTerm x)})) - -unPrecedence :: Phantoms.TTerm Ast.Precedence -> Phantoms.TTerm Int -unPrecedence x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.ast.Precedence")))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -unSymbol :: Phantoms.TTerm Ast.Symbol -> Phantoms.TTerm String -unSymbol x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.ast.Symbol")))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -wsBreak :: Phantoms.TTerm Ast.Ws -wsBreak = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.Ws"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "break"), - Core.fieldTerm = Core.TermUnit}})) - -wsBreakAndIndent :: Phantoms.TTerm String -> Phantoms.TTerm Ast.Ws -wsBreakAndIndent x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.Ws"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "breakAndIndent"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -wsDoubleBreak :: Phantoms.TTerm Ast.Ws -wsDoubleBreak = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.Ws"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "doubleBreak"), - Core.fieldTerm = Core.TermUnit}})) - -wsNone :: Phantoms.TTerm Ast.Ws -wsNone = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.Ws"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "none"), - Core.fieldTerm = Core.TermUnit}})) - -wsSpace :: Phantoms.TTerm Ast.Ws -wsSpace = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.Ws"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "space"), - Core.fieldTerm = Core.TermUnit}})) diff --git a/src/gen-main/haskell/Hydra/Dsl/Classes.hs b/src/gen-main/haskell/Hydra/Dsl/Classes.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Dsl/Classes.hs +++ /dev/null @@ -1,31 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | DSL functions for hydra.classes - -module Hydra.Dsl.Classes where - -import qualified Hydra.Classes as Classes -import qualified Hydra.Core as Core -import qualified Hydra.Phantoms as Phantoms -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -typeClassEquality :: Phantoms.TTerm Classes.TypeClass -typeClassEquality = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.classes.TypeClass"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "equality"), - Core.fieldTerm = Core.TermUnit}})) - -typeClassOrdering :: Phantoms.TTerm Classes.TypeClass -typeClassOrdering = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.classes.TypeClass"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "ordering"), - Core.fieldTerm = Core.TermUnit}})) diff --git a/src/gen-main/haskell/Hydra/Dsl/Coders.hs b/src/gen-main/haskell/Hydra/Dsl/Coders.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Dsl/Coders.hs +++ /dev/null @@ -1,788 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | DSL functions for hydra.coders - -module Hydra.Dsl.Coders where - -import qualified Hydra.Coders as Coders -import qualified Hydra.Core as Core -import qualified Hydra.Graph as Graph -import qualified Hydra.Phantoms as Phantoms -import qualified Hydra.Util as Util -import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -adapterContext :: Phantoms.TTerm Graph.Graph -> Phantoms.TTerm Coders.Language -> Phantoms.TTerm (M.Map Core.Name (Util.Adapter Core.Type Core.Type Core.Term Core.Term)) -> Phantoms.TTerm Coders.AdapterContext -adapterContext graph language adapters = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.coders.AdapterContext"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "graph"), - Core.fieldTerm = (Phantoms.unTTerm graph)}, - Core.Field { - Core.fieldName = (Core.Name "language"), - Core.fieldTerm = (Phantoms.unTTerm language)}, - Core.Field { - Core.fieldName = (Core.Name "adapters"), - Core.fieldTerm = (Phantoms.unTTerm adapters)}]})) - -adapterContextAdapters :: Phantoms.TTerm Coders.AdapterContext -> Phantoms.TTerm (M.Map Core.Name (Util.Adapter Core.Type Core.Type Core.Term Core.Term)) -adapterContextAdapters x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.AdapterContext"), - Core.projectionField = (Core.Name "adapters")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -adapterContextGraph :: Phantoms.TTerm Coders.AdapterContext -> Phantoms.TTerm Graph.Graph -adapterContextGraph x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.AdapterContext"), - Core.projectionField = (Core.Name "graph")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -adapterContextLanguage :: Phantoms.TTerm Coders.AdapterContext -> Phantoms.TTerm Coders.Language -adapterContextLanguage x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.AdapterContext"), - Core.projectionField = (Core.Name "language")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -adapterContextWithAdapters :: Phantoms.TTerm Coders.AdapterContext -> Phantoms.TTerm (M.Map Core.Name (Util.Adapter Core.Type Core.Type Core.Term Core.Term)) -> Phantoms.TTerm Coders.AdapterContext -adapterContextWithAdapters original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.coders.AdapterContext"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "graph"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.AdapterContext"), - Core.projectionField = (Core.Name "graph")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "language"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.AdapterContext"), - Core.projectionField = (Core.Name "language")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "adapters"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -adapterContextWithGraph :: Phantoms.TTerm Coders.AdapterContext -> Phantoms.TTerm Graph.Graph -> Phantoms.TTerm Coders.AdapterContext -adapterContextWithGraph original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.coders.AdapterContext"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "graph"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "language"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.AdapterContext"), - Core.projectionField = (Core.Name "language")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "adapters"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.AdapterContext"), - Core.projectionField = (Core.Name "adapters")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -adapterContextWithLanguage :: Phantoms.TTerm Coders.AdapterContext -> Phantoms.TTerm Coders.Language -> Phantoms.TTerm Coders.AdapterContext -adapterContextWithLanguage original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.coders.AdapterContext"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "graph"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.AdapterContext"), - Core.projectionField = (Core.Name "graph")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "language"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "adapters"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.AdapterContext"), - Core.projectionField = (Core.Name "adapters")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -coderDirectionDecode :: Phantoms.TTerm Coders.CoderDirection -coderDirectionDecode = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.coders.CoderDirection"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "decode"), - Core.fieldTerm = Core.TermUnit}})) - -coderDirectionEncode :: Phantoms.TTerm Coders.CoderDirection -coderDirectionEncode = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.coders.CoderDirection"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "encode"), - Core.fieldTerm = Core.TermUnit}})) - -language :: Phantoms.TTerm Coders.LanguageName -> Phantoms.TTerm Coders.LanguageConstraints -> Phantoms.TTerm Coders.Language -language name constraints = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.coders.Language"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm name)}, - Core.Field { - Core.fieldName = (Core.Name "constraints"), - Core.fieldTerm = (Phantoms.unTTerm constraints)}]})) - -languageConstraints :: Phantoms.TTerm Coders.Language -> Phantoms.TTerm Coders.LanguageConstraints -languageConstraints x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.Language"), - Core.projectionField = (Core.Name "constraints")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -languageConstraintsEliminationVariants :: Phantoms.TTerm Coders.LanguageConstraints -> Phantoms.TTerm (S.Set Variants.EliminationVariant) -languageConstraintsEliminationVariants x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "eliminationVariants")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -languageConstraintsFloatTypes :: Phantoms.TTerm Coders.LanguageConstraints -> Phantoms.TTerm (S.Set Core.FloatType) -languageConstraintsFloatTypes x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "floatTypes")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -languageConstraintsFunctionVariants :: Phantoms.TTerm Coders.LanguageConstraints -> Phantoms.TTerm (S.Set Variants.FunctionVariant) -languageConstraintsFunctionVariants x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "functionVariants")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -languageConstraintsIntegerTypes :: Phantoms.TTerm Coders.LanguageConstraints -> Phantoms.TTerm (S.Set Core.IntegerType) -languageConstraintsIntegerTypes x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "integerTypes")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -languageConstraintsLiteralVariants :: Phantoms.TTerm Coders.LanguageConstraints -> Phantoms.TTerm (S.Set Variants.LiteralVariant) -languageConstraintsLiteralVariants x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "literalVariants")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -languageConstraintsTermVariants :: Phantoms.TTerm Coders.LanguageConstraints -> Phantoms.TTerm (S.Set Variants.TermVariant) -languageConstraintsTermVariants x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "termVariants")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -languageConstraintsTypeVariants :: Phantoms.TTerm Coders.LanguageConstraints -> Phantoms.TTerm (S.Set Variants.TypeVariant) -languageConstraintsTypeVariants x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "typeVariants")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -languageConstraintsTypes :: Phantoms.TTerm Coders.LanguageConstraints -> Phantoms.TTerm (Core.Type -> Bool) -languageConstraintsTypes x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "types")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -languageConstraintsWithEliminationVariants :: Phantoms.TTerm Coders.LanguageConstraints -> Phantoms.TTerm (S.Set Variants.EliminationVariant) -> Phantoms.TTerm Coders.LanguageConstraints -languageConstraintsWithEliminationVariants original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "eliminationVariants"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "literalVariants"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "literalVariants")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "floatTypes"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "floatTypes")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "functionVariants"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "functionVariants")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "integerTypes"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "integerTypes")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "termVariants"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "termVariants")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "typeVariants"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "typeVariants")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "types"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "types")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -languageConstraintsWithFloatTypes :: Phantoms.TTerm Coders.LanguageConstraints -> Phantoms.TTerm (S.Set Core.FloatType) -> Phantoms.TTerm Coders.LanguageConstraints -languageConstraintsWithFloatTypes original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "eliminationVariants"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "eliminationVariants")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "literalVariants"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "literalVariants")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "floatTypes"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "functionVariants"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "functionVariants")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "integerTypes"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "integerTypes")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "termVariants"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "termVariants")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "typeVariants"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "typeVariants")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "types"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "types")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -languageConstraintsWithFunctionVariants :: Phantoms.TTerm Coders.LanguageConstraints -> Phantoms.TTerm (S.Set Variants.FunctionVariant) -> Phantoms.TTerm Coders.LanguageConstraints -languageConstraintsWithFunctionVariants original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "eliminationVariants"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "eliminationVariants")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "literalVariants"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "literalVariants")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "floatTypes"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "floatTypes")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "functionVariants"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "integerTypes"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "integerTypes")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "termVariants"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "termVariants")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "typeVariants"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "typeVariants")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "types"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "types")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -languageConstraintsWithIntegerTypes :: Phantoms.TTerm Coders.LanguageConstraints -> Phantoms.TTerm (S.Set Core.IntegerType) -> Phantoms.TTerm Coders.LanguageConstraints -languageConstraintsWithIntegerTypes original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "eliminationVariants"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "eliminationVariants")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "literalVariants"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "literalVariants")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "floatTypes"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "floatTypes")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "functionVariants"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "functionVariants")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "integerTypes"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "termVariants"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "termVariants")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "typeVariants"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "typeVariants")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "types"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "types")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -languageConstraintsWithLiteralVariants :: Phantoms.TTerm Coders.LanguageConstraints -> Phantoms.TTerm (S.Set Variants.LiteralVariant) -> Phantoms.TTerm Coders.LanguageConstraints -languageConstraintsWithLiteralVariants original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "eliminationVariants"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "eliminationVariants")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "literalVariants"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "floatTypes"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "floatTypes")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "functionVariants"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "functionVariants")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "integerTypes"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "integerTypes")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "termVariants"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "termVariants")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "typeVariants"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "typeVariants")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "types"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "types")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -languageConstraintsWithTermVariants :: Phantoms.TTerm Coders.LanguageConstraints -> Phantoms.TTerm (S.Set Variants.TermVariant) -> Phantoms.TTerm Coders.LanguageConstraints -languageConstraintsWithTermVariants original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "eliminationVariants"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "eliminationVariants")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "literalVariants"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "literalVariants")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "floatTypes"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "floatTypes")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "functionVariants"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "functionVariants")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "integerTypes"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "integerTypes")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "termVariants"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "typeVariants"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "typeVariants")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "types"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "types")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -languageConstraintsWithTypeVariants :: Phantoms.TTerm Coders.LanguageConstraints -> Phantoms.TTerm (S.Set Variants.TypeVariant) -> Phantoms.TTerm Coders.LanguageConstraints -languageConstraintsWithTypeVariants original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "eliminationVariants"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "eliminationVariants")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "literalVariants"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "literalVariants")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "floatTypes"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "floatTypes")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "functionVariants"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "functionVariants")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "integerTypes"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "integerTypes")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "termVariants"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "termVariants")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "typeVariants"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "types"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "types")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -languageConstraintsWithTypes :: Phantoms.TTerm Coders.LanguageConstraints -> Phantoms.TTerm (Core.Type -> Bool) -> Phantoms.TTerm Coders.LanguageConstraints -languageConstraintsWithTypes original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "eliminationVariants"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "eliminationVariants")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "literalVariants"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "literalVariants")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "floatTypes"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "floatTypes")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "functionVariants"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "functionVariants")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "integerTypes"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "integerTypes")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "termVariants"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "termVariants")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "typeVariants"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.projectionField = (Core.Name "typeVariants")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "types"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -languageConstraints_ :: Phantoms.TTerm (S.Set Variants.EliminationVariant) -> Phantoms.TTerm (S.Set Variants.LiteralVariant) -> Phantoms.TTerm (S.Set Core.FloatType) -> Phantoms.TTerm (S.Set Variants.FunctionVariant) -> Phantoms.TTerm (S.Set Core.IntegerType) -> Phantoms.TTerm (S.Set Variants.TermVariant) -> Phantoms.TTerm (S.Set Variants.TypeVariant) -> Phantoms.TTerm (Core.Type -> Bool) -> Phantoms.TTerm Coders.LanguageConstraints -languageConstraints_ eliminationVariants literalVariants floatTypes functionVariants integerTypes termVariants typeVariants types = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.coders.LanguageConstraints"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "eliminationVariants"), - Core.fieldTerm = (Phantoms.unTTerm eliminationVariants)}, - Core.Field { - Core.fieldName = (Core.Name "literalVariants"), - Core.fieldTerm = (Phantoms.unTTerm literalVariants)}, - Core.Field { - Core.fieldName = (Core.Name "floatTypes"), - Core.fieldTerm = (Phantoms.unTTerm floatTypes)}, - Core.Field { - Core.fieldName = (Core.Name "functionVariants"), - Core.fieldTerm = (Phantoms.unTTerm functionVariants)}, - Core.Field { - Core.fieldName = (Core.Name "integerTypes"), - Core.fieldTerm = (Phantoms.unTTerm integerTypes)}, - Core.Field { - Core.fieldName = (Core.Name "termVariants"), - Core.fieldTerm = (Phantoms.unTTerm termVariants)}, - Core.Field { - Core.fieldName = (Core.Name "typeVariants"), - Core.fieldTerm = (Phantoms.unTTerm typeVariants)}, - Core.Field { - Core.fieldName = (Core.Name "types"), - Core.fieldTerm = (Phantoms.unTTerm types)}]})) - -languageName :: Phantoms.TTerm Coders.Language -> Phantoms.TTerm Coders.LanguageName -languageName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.Language"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -languageName_ :: Phantoms.TTerm String -> Phantoms.TTerm Coders.LanguageName -languageName_ x = - Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.coders.LanguageName"), - Core.wrappedTermBody = (Phantoms.unTTerm x)})) - -languageWithConstraints :: Phantoms.TTerm Coders.Language -> Phantoms.TTerm Coders.LanguageConstraints -> Phantoms.TTerm Coders.Language -languageWithConstraints original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.coders.Language"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.Language"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "constraints"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -languageWithName :: Phantoms.TTerm Coders.Language -> Phantoms.TTerm Coders.LanguageName -> Phantoms.TTerm Coders.Language -languageWithName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.coders.Language"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "constraints"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.coders.Language"), - Core.projectionField = (Core.Name "constraints")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -traversalOrderPost :: Phantoms.TTerm Coders.TraversalOrder -traversalOrderPost = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.coders.TraversalOrder"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "post"), - Core.fieldTerm = Core.TermUnit}})) - -traversalOrderPre :: Phantoms.TTerm Coders.TraversalOrder -traversalOrderPre = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.coders.TraversalOrder"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "pre"), - Core.fieldTerm = Core.TermUnit}})) - -unLanguageName :: Phantoms.TTerm Coders.LanguageName -> Phantoms.TTerm String -unLanguageName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.coders.LanguageName")))), - Core.applicationArgument = (Phantoms.unTTerm x)})) diff --git a/src/gen-main/haskell/Hydra/Dsl/Context.hs b/src/gen-main/haskell/Hydra/Dsl/Context.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Dsl/Context.hs +++ /dev/null @@ -1,183 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | DSL functions for hydra.context - -module Hydra.Dsl.Context where - -import qualified Hydra.Context as Context -import qualified Hydra.Core as Core -import qualified Hydra.Phantoms as Phantoms -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -context :: Phantoms.TTerm [String] -> Phantoms.TTerm [String] -> Phantoms.TTerm (M.Map Core.Name Core.Term) -> Phantoms.TTerm Context.Context -context trace messages other = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.context.Context"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "trace"), - Core.fieldTerm = (Phantoms.unTTerm trace)}, - Core.Field { - Core.fieldName = (Core.Name "messages"), - Core.fieldTerm = (Phantoms.unTTerm messages)}, - Core.Field { - Core.fieldName = (Core.Name "other"), - Core.fieldTerm = (Phantoms.unTTerm other)}]})) - -contextMessages :: Phantoms.TTerm Context.Context -> Phantoms.TTerm [String] -contextMessages x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.context.Context"), - Core.projectionField = (Core.Name "messages")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -contextOther :: Phantoms.TTerm Context.Context -> Phantoms.TTerm (M.Map Core.Name Core.Term) -contextOther x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.context.Context"), - Core.projectionField = (Core.Name "other")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -contextTrace :: Phantoms.TTerm Context.Context -> Phantoms.TTerm [String] -contextTrace x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.context.Context"), - Core.projectionField = (Core.Name "trace")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -contextWithMessages :: Phantoms.TTerm Context.Context -> Phantoms.TTerm [String] -> Phantoms.TTerm Context.Context -contextWithMessages original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.context.Context"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "trace"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.context.Context"), - Core.projectionField = (Core.Name "trace")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "messages"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "other"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.context.Context"), - Core.projectionField = (Core.Name "other")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -contextWithOther :: Phantoms.TTerm Context.Context -> Phantoms.TTerm (M.Map Core.Name Core.Term) -> Phantoms.TTerm Context.Context -contextWithOther original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.context.Context"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "trace"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.context.Context"), - Core.projectionField = (Core.Name "trace")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "messages"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.context.Context"), - Core.projectionField = (Core.Name "messages")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "other"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -contextWithTrace :: Phantoms.TTerm Context.Context -> Phantoms.TTerm [String] -> Phantoms.TTerm Context.Context -contextWithTrace original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.context.Context"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "trace"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "messages"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.context.Context"), - Core.projectionField = (Core.Name "messages")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "other"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.context.Context"), - Core.projectionField = (Core.Name "other")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -inContext :: Phantoms.TTerm e -> Phantoms.TTerm Context.Context -> Phantoms.TTerm (Context.InContext e) -inContext object context = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.context.InContext"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "object"), - Core.fieldTerm = (Phantoms.unTTerm object)}, - Core.Field { - Core.fieldName = (Core.Name "context"), - Core.fieldTerm = (Phantoms.unTTerm context)}]})) - -inContextContext :: Phantoms.TTerm (Context.InContext e) -> Phantoms.TTerm Context.Context -inContextContext x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.context.InContext"), - Core.projectionField = (Core.Name "context")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -inContextObject :: Phantoms.TTerm (Context.InContext e) -> Phantoms.TTerm e -inContextObject x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.context.InContext"), - Core.projectionField = (Core.Name "object")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -inContextWithContext :: Phantoms.TTerm (Context.InContext e) -> Phantoms.TTerm Context.Context -> Phantoms.TTerm (Context.InContext e) -inContextWithContext original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.context.InContext"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "object"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.context.InContext"), - Core.projectionField = (Core.Name "object")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "context"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -inContextWithObject :: Phantoms.TTerm (Context.InContext e) -> Phantoms.TTerm e -> Phantoms.TTerm (Context.InContext e) -inContextWithObject original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.context.InContext"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "object"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "context"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.context.InContext"), - Core.projectionField = (Core.Name "context")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) diff --git a/src/gen-main/haskell/Hydra/Dsl/Core.hs b/src/gen-main/haskell/Hydra/Dsl/Core.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Dsl/Core.hs +++ /dev/null @@ -1,2164 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | DSL functions for hydra.core - -module Hydra.Dsl.Core where - -import qualified Hydra.Core as Core -import qualified Hydra.Phantoms as Phantoms -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -annotatedTerm :: Phantoms.TTerm Core.Term -> Phantoms.TTerm (M.Map Core.Name Core.Term) -> Phantoms.TTerm Core.AnnotatedTerm -annotatedTerm body annotation = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.AnnotatedTerm"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Phantoms.unTTerm body)}, - Core.Field { - Core.fieldName = (Core.Name "annotation"), - Core.fieldTerm = (Phantoms.unTTerm annotation)}]})) - -annotatedTermAnnotation :: Phantoms.TTerm Core.AnnotatedTerm -> Phantoms.TTerm (M.Map Core.Name Core.Term) -annotatedTermAnnotation x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.AnnotatedTerm"), - Core.projectionField = (Core.Name "annotation")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -annotatedTermBody :: Phantoms.TTerm Core.AnnotatedTerm -> Phantoms.TTerm Core.Term -annotatedTermBody x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.AnnotatedTerm"), - Core.projectionField = (Core.Name "body")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -annotatedTermWithAnnotation :: Phantoms.TTerm Core.AnnotatedTerm -> Phantoms.TTerm (M.Map Core.Name Core.Term) -> Phantoms.TTerm Core.AnnotatedTerm -annotatedTermWithAnnotation original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.AnnotatedTerm"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.AnnotatedTerm"), - Core.projectionField = (Core.Name "body")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "annotation"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -annotatedTermWithBody :: Phantoms.TTerm Core.AnnotatedTerm -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Core.AnnotatedTerm -annotatedTermWithBody original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.AnnotatedTerm"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "annotation"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.AnnotatedTerm"), - Core.projectionField = (Core.Name "annotation")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -annotatedType :: Phantoms.TTerm Core.Type -> Phantoms.TTerm (M.Map Core.Name Core.Term) -> Phantoms.TTerm Core.AnnotatedType -annotatedType body annotation = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.AnnotatedType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Phantoms.unTTerm body)}, - Core.Field { - Core.fieldName = (Core.Name "annotation"), - Core.fieldTerm = (Phantoms.unTTerm annotation)}]})) - -annotatedTypeAnnotation :: Phantoms.TTerm Core.AnnotatedType -> Phantoms.TTerm (M.Map Core.Name Core.Term) -annotatedTypeAnnotation x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.AnnotatedType"), - Core.projectionField = (Core.Name "annotation")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -annotatedTypeBody :: Phantoms.TTerm Core.AnnotatedType -> Phantoms.TTerm Core.Type -annotatedTypeBody x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.AnnotatedType"), - Core.projectionField = (Core.Name "body")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -annotatedTypeWithAnnotation :: Phantoms.TTerm Core.AnnotatedType -> Phantoms.TTerm (M.Map Core.Name Core.Term) -> Phantoms.TTerm Core.AnnotatedType -annotatedTypeWithAnnotation original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.AnnotatedType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.AnnotatedType"), - Core.projectionField = (Core.Name "body")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "annotation"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -annotatedTypeWithBody :: Phantoms.TTerm Core.AnnotatedType -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Core.AnnotatedType -annotatedTypeWithBody original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.AnnotatedType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "annotation"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.AnnotatedType"), - Core.projectionField = (Core.Name "annotation")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -application :: Phantoms.TTerm Core.Term -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Core.Application -application function argument = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Application"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "function"), - Core.fieldTerm = (Phantoms.unTTerm function)}, - Core.Field { - Core.fieldName = (Core.Name "argument"), - Core.fieldTerm = (Phantoms.unTTerm argument)}]})) - -applicationArgument :: Phantoms.TTerm Core.Application -> Phantoms.TTerm Core.Term -applicationArgument x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Application"), - Core.projectionField = (Core.Name "argument")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -applicationFunction :: Phantoms.TTerm Core.Application -> Phantoms.TTerm Core.Term -applicationFunction x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Application"), - Core.projectionField = (Core.Name "function")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -applicationType :: Phantoms.TTerm Core.Type -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Core.ApplicationType -applicationType function argument = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.ApplicationType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "function"), - Core.fieldTerm = (Phantoms.unTTerm function)}, - Core.Field { - Core.fieldName = (Core.Name "argument"), - Core.fieldTerm = (Phantoms.unTTerm argument)}]})) - -applicationTypeArgument :: Phantoms.TTerm Core.ApplicationType -> Phantoms.TTerm Core.Type -applicationTypeArgument x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.ApplicationType"), - Core.projectionField = (Core.Name "argument")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -applicationTypeFunction :: Phantoms.TTerm Core.ApplicationType -> Phantoms.TTerm Core.Type -applicationTypeFunction x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.ApplicationType"), - Core.projectionField = (Core.Name "function")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -applicationTypeWithArgument :: Phantoms.TTerm Core.ApplicationType -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Core.ApplicationType -applicationTypeWithArgument original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.ApplicationType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "function"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.ApplicationType"), - Core.projectionField = (Core.Name "function")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "argument"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -applicationTypeWithFunction :: Phantoms.TTerm Core.ApplicationType -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Core.ApplicationType -applicationTypeWithFunction original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.ApplicationType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "function"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "argument"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.ApplicationType"), - Core.projectionField = (Core.Name "argument")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -applicationWithArgument :: Phantoms.TTerm Core.Application -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Core.Application -applicationWithArgument original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Application"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "function"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Application"), - Core.projectionField = (Core.Name "function")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "argument"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -applicationWithFunction :: Phantoms.TTerm Core.Application -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Core.Application -applicationWithFunction original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Application"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "function"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "argument"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Application"), - Core.projectionField = (Core.Name "argument")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -binding :: Phantoms.TTerm Core.Name -> Phantoms.TTerm Core.Term -> Phantoms.TTerm (Maybe Core.TypeScheme) -> Phantoms.TTerm Core.Binding -binding name term type_ = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Binding"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm name)}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Phantoms.unTTerm term)}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Phantoms.unTTerm type_)}]})) - -bindingName :: Phantoms.TTerm Core.Binding -> Phantoms.TTerm Core.Name -bindingName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Binding"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -bindingTerm :: Phantoms.TTerm Core.Binding -> Phantoms.TTerm Core.Term -bindingTerm x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Binding"), - Core.projectionField = (Core.Name "term")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -bindingType :: Phantoms.TTerm Core.Binding -> Phantoms.TTerm (Maybe Core.TypeScheme) -bindingType x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Binding"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -bindingWithName :: Phantoms.TTerm Core.Binding -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core.Binding -bindingWithName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Binding"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Binding"), - Core.projectionField = (Core.Name "term")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Binding"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -bindingWithTerm :: Phantoms.TTerm Core.Binding -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Core.Binding -bindingWithTerm original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Binding"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Binding"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Binding"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -bindingWithType :: Phantoms.TTerm Core.Binding -> Phantoms.TTerm (Maybe Core.TypeScheme) -> Phantoms.TTerm Core.Binding -bindingWithType original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Binding"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Binding"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Binding"), - Core.projectionField = (Core.Name "term")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -caseStatement :: Phantoms.TTerm Core.Name -> Phantoms.TTerm (Maybe Core.Term) -> Phantoms.TTerm [Core.Field] -> Phantoms.TTerm Core.CaseStatement -caseStatement typeName default_ cases = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.CaseStatement"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Phantoms.unTTerm typeName)}, - Core.Field { - Core.fieldName = (Core.Name "default"), - Core.fieldTerm = (Phantoms.unTTerm default_)}, - Core.Field { - Core.fieldName = (Core.Name "cases"), - Core.fieldTerm = (Phantoms.unTTerm cases)}]})) - -caseStatementCases :: Phantoms.TTerm Core.CaseStatement -> Phantoms.TTerm [Core.Field] -caseStatementCases x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.CaseStatement"), - Core.projectionField = (Core.Name "cases")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -caseStatementDefault :: Phantoms.TTerm Core.CaseStatement -> Phantoms.TTerm (Maybe Core.Term) -caseStatementDefault x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.CaseStatement"), - Core.projectionField = (Core.Name "default")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -caseStatementTypeName :: Phantoms.TTerm Core.CaseStatement -> Phantoms.TTerm Core.Name -caseStatementTypeName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.CaseStatement"), - Core.projectionField = (Core.Name "typeName")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -caseStatementWithCases :: Phantoms.TTerm Core.CaseStatement -> Phantoms.TTerm [Core.Field] -> Phantoms.TTerm Core.CaseStatement -caseStatementWithCases original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.CaseStatement"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.CaseStatement"), - Core.projectionField = (Core.Name "typeName")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "default"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.CaseStatement"), - Core.projectionField = (Core.Name "default")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "cases"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -caseStatementWithDefault :: Phantoms.TTerm Core.CaseStatement -> Phantoms.TTerm (Maybe Core.Term) -> Phantoms.TTerm Core.CaseStatement -caseStatementWithDefault original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.CaseStatement"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.CaseStatement"), - Core.projectionField = (Core.Name "typeName")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "default"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "cases"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.CaseStatement"), - Core.projectionField = (Core.Name "cases")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -caseStatementWithTypeName :: Phantoms.TTerm Core.CaseStatement -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core.CaseStatement -caseStatementWithTypeName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.CaseStatement"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "default"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.CaseStatement"), - Core.projectionField = (Core.Name "default")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "cases"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.CaseStatement"), - Core.projectionField = (Core.Name "cases")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -eitherType :: Phantoms.TTerm Core.Type -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Core.EitherType -eitherType left right = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.EitherType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "left"), - Core.fieldTerm = (Phantoms.unTTerm left)}, - Core.Field { - Core.fieldName = (Core.Name "right"), - Core.fieldTerm = (Phantoms.unTTerm right)}]})) - -eitherTypeLeft :: Phantoms.TTerm Core.EitherType -> Phantoms.TTerm Core.Type -eitherTypeLeft x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.EitherType"), - Core.projectionField = (Core.Name "left")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -eitherTypeRight :: Phantoms.TTerm Core.EitherType -> Phantoms.TTerm Core.Type -eitherTypeRight x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.EitherType"), - Core.projectionField = (Core.Name "right")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -eitherTypeWithLeft :: Phantoms.TTerm Core.EitherType -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Core.EitherType -eitherTypeWithLeft original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.EitherType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "left"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "right"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.EitherType"), - Core.projectionField = (Core.Name "right")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -eitherTypeWithRight :: Phantoms.TTerm Core.EitherType -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Core.EitherType -eitherTypeWithRight original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.EitherType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "left"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.EitherType"), - Core.projectionField = (Core.Name "left")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "right"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -eliminationRecord :: Phantoms.TTerm Core.Projection -> Phantoms.TTerm Core.Elimination -eliminationRecord x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Elimination"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -eliminationUnion :: Phantoms.TTerm Core.CaseStatement -> Phantoms.TTerm Core.Elimination -eliminationUnion x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Elimination"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "union"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -eliminationWrap :: Phantoms.TTerm Core.Name -> Phantoms.TTerm Core.Elimination -eliminationWrap x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Elimination"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wrap"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -field :: Phantoms.TTerm Core.Name -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Core.Field -field name term = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm name)}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Phantoms.unTTerm term)}]})) - -fieldName :: Phantoms.TTerm Core.Field -> Phantoms.TTerm Core.Name -fieldName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -fieldTerm :: Phantoms.TTerm Core.Field -> Phantoms.TTerm Core.Term -fieldTerm x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionField = (Core.Name "term")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -fieldType :: Phantoms.TTerm Core.Name -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Core.FieldType -fieldType name type_ = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.FieldType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm name)}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Phantoms.unTTerm type_)}]})) - -fieldTypeName :: Phantoms.TTerm Core.FieldType -> Phantoms.TTerm Core.Name -fieldTypeName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.FieldType"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -fieldTypeType :: Phantoms.TTerm Core.FieldType -> Phantoms.TTerm Core.Type -fieldTypeType x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.FieldType"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -fieldTypeWithName :: Phantoms.TTerm Core.FieldType -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core.FieldType -fieldTypeWithName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.FieldType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.FieldType"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -fieldTypeWithType :: Phantoms.TTerm Core.FieldType -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Core.FieldType -fieldTypeWithType original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.FieldType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.FieldType"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -fieldWithName :: Phantoms.TTerm Core.Field -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core.Field -fieldWithName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionField = (Core.Name "term")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -fieldWithTerm :: Phantoms.TTerm Core.Field -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Core.Field -fieldWithTerm original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -floatTypeBigfloat :: Phantoms.TTerm Core.FloatType -floatTypeBigfloat = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.FloatType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "bigfloat"), - Core.fieldTerm = Core.TermUnit}})) - -floatTypeFloat32 :: Phantoms.TTerm Core.FloatType -floatTypeFloat32 = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.FloatType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "float32"), - Core.fieldTerm = Core.TermUnit}})) - -floatTypeFloat64 :: Phantoms.TTerm Core.FloatType -floatTypeFloat64 = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.FloatType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "float64"), - Core.fieldTerm = Core.TermUnit}})) - -floatValueBigfloat :: Phantoms.TTerm Double -> Phantoms.TTerm Core.FloatValue -floatValueBigfloat x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.FloatValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "bigfloat"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -floatValueFloat32 :: Phantoms.TTerm Float -> Phantoms.TTerm Core.FloatValue -floatValueFloat32 x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.FloatValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "float32"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -floatValueFloat64 :: Phantoms.TTerm Double -> Phantoms.TTerm Core.FloatValue -floatValueFloat64 x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.FloatValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "float64"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -forallType :: Phantoms.TTerm Core.Name -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Core.ForallType -forallType parameter body = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.ForallType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "parameter"), - Core.fieldTerm = (Phantoms.unTTerm parameter)}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Phantoms.unTTerm body)}]})) - -forallTypeBody :: Phantoms.TTerm Core.ForallType -> Phantoms.TTerm Core.Type -forallTypeBody x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.ForallType"), - Core.projectionField = (Core.Name "body")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -forallTypeParameter :: Phantoms.TTerm Core.ForallType -> Phantoms.TTerm Core.Name -forallTypeParameter x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.ForallType"), - Core.projectionField = (Core.Name "parameter")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -forallTypeWithBody :: Phantoms.TTerm Core.ForallType -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Core.ForallType -forallTypeWithBody original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.ForallType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "parameter"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.ForallType"), - Core.projectionField = (Core.Name "parameter")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -forallTypeWithParameter :: Phantoms.TTerm Core.ForallType -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core.ForallType -forallTypeWithParameter original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.ForallType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "parameter"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.ForallType"), - Core.projectionField = (Core.Name "body")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -functionElimination :: Phantoms.TTerm Core.Elimination -> Phantoms.TTerm Core.Function -functionElimination x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Function"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "elimination"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -functionLambda :: Phantoms.TTerm Core.Lambda -> Phantoms.TTerm Core.Function -functionLambda x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Function"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "lambda"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -functionPrimitive :: Phantoms.TTerm Core.Name -> Phantoms.TTerm Core.Function -functionPrimitive x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Function"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "primitive"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -functionType :: Phantoms.TTerm Core.Type -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Core.FunctionType -functionType domain codomain = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.FunctionType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "domain"), - Core.fieldTerm = (Phantoms.unTTerm domain)}, - Core.Field { - Core.fieldName = (Core.Name "codomain"), - Core.fieldTerm = (Phantoms.unTTerm codomain)}]})) - -functionTypeCodomain :: Phantoms.TTerm Core.FunctionType -> Phantoms.TTerm Core.Type -functionTypeCodomain x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.FunctionType"), - Core.projectionField = (Core.Name "codomain")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -functionTypeDomain :: Phantoms.TTerm Core.FunctionType -> Phantoms.TTerm Core.Type -functionTypeDomain x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.FunctionType"), - Core.projectionField = (Core.Name "domain")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -functionTypeWithCodomain :: Phantoms.TTerm Core.FunctionType -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Core.FunctionType -functionTypeWithCodomain original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.FunctionType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "domain"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.FunctionType"), - Core.projectionField = (Core.Name "domain")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "codomain"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -functionTypeWithDomain :: Phantoms.TTerm Core.FunctionType -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Core.FunctionType -functionTypeWithDomain original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.FunctionType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "domain"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "codomain"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.FunctionType"), - Core.projectionField = (Core.Name "codomain")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -injection :: Phantoms.TTerm Core.Name -> Phantoms.TTerm Core.Field -> Phantoms.TTerm Core.Injection -injection typeName field = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Phantoms.unTTerm typeName)}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Phantoms.unTTerm field)}]})) - -injectionField :: Phantoms.TTerm Core.Injection -> Phantoms.TTerm Core.Field -injectionField x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionField = (Core.Name "field")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -injectionTypeName :: Phantoms.TTerm Core.Injection -> Phantoms.TTerm Core.Name -injectionTypeName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionField = (Core.Name "typeName")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -injectionWithField :: Phantoms.TTerm Core.Injection -> Phantoms.TTerm Core.Field -> Phantoms.TTerm Core.Injection -injectionWithField original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionField = (Core.Name "typeName")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -injectionWithTypeName :: Phantoms.TTerm Core.Injection -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core.Injection -injectionWithTypeName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionField = (Core.Name "field")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -integerTypeBigint :: Phantoms.TTerm Core.IntegerType -integerTypeBigint = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "bigint"), - Core.fieldTerm = Core.TermUnit}})) - -integerTypeInt16 :: Phantoms.TTerm Core.IntegerType -integerTypeInt16 = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int16"), - Core.fieldTerm = Core.TermUnit}})) - -integerTypeInt32 :: Phantoms.TTerm Core.IntegerType -integerTypeInt32 = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int32"), - Core.fieldTerm = Core.TermUnit}})) - -integerTypeInt64 :: Phantoms.TTerm Core.IntegerType -integerTypeInt64 = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int64"), - Core.fieldTerm = Core.TermUnit}})) - -integerTypeInt8 :: Phantoms.TTerm Core.IntegerType -integerTypeInt8 = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int8"), - Core.fieldTerm = Core.TermUnit}})) - -integerTypeUint16 :: Phantoms.TTerm Core.IntegerType -integerTypeUint16 = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "uint16"), - Core.fieldTerm = Core.TermUnit}})) - -integerTypeUint32 :: Phantoms.TTerm Core.IntegerType -integerTypeUint32 = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "uint32"), - Core.fieldTerm = Core.TermUnit}})) - -integerTypeUint64 :: Phantoms.TTerm Core.IntegerType -integerTypeUint64 = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "uint64"), - Core.fieldTerm = Core.TermUnit}})) - -integerTypeUint8 :: Phantoms.TTerm Core.IntegerType -integerTypeUint8 = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "uint8"), - Core.fieldTerm = Core.TermUnit}})) - -integerValueBigint :: Phantoms.TTerm Integer -> Phantoms.TTerm Core.IntegerValue -integerValueBigint x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "bigint"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -integerValueInt16 :: Phantoms.TTerm I.Int16 -> Phantoms.TTerm Core.IntegerValue -integerValueInt16 x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int16"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -integerValueInt32 :: Phantoms.TTerm Int -> Phantoms.TTerm Core.IntegerValue -integerValueInt32 x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int32"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -integerValueInt64 :: Phantoms.TTerm I.Int64 -> Phantoms.TTerm Core.IntegerValue -integerValueInt64 x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int64"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -integerValueInt8 :: Phantoms.TTerm I.Int8 -> Phantoms.TTerm Core.IntegerValue -integerValueInt8 x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int8"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -integerValueUint16 :: Phantoms.TTerm Int -> Phantoms.TTerm Core.IntegerValue -integerValueUint16 x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "uint16"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -integerValueUint32 :: Phantoms.TTerm I.Int64 -> Phantoms.TTerm Core.IntegerValue -integerValueUint32 x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "uint32"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -integerValueUint64 :: Phantoms.TTerm Integer -> Phantoms.TTerm Core.IntegerValue -integerValueUint64 x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "uint64"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -integerValueUint8 :: Phantoms.TTerm I.Int16 -> Phantoms.TTerm Core.IntegerValue -integerValueUint8 x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "uint8"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -lambda :: Phantoms.TTerm Core.Name -> Phantoms.TTerm (Maybe Core.Type) -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Core.Lambda -lambda parameter domain body = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Lambda"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "parameter"), - Core.fieldTerm = (Phantoms.unTTerm parameter)}, - Core.Field { - Core.fieldName = (Core.Name "domain"), - Core.fieldTerm = (Phantoms.unTTerm domain)}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Phantoms.unTTerm body)}]})) - -lambdaBody :: Phantoms.TTerm Core.Lambda -> Phantoms.TTerm Core.Term -lambdaBody x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Lambda"), - Core.projectionField = (Core.Name "body")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -lambdaDomain :: Phantoms.TTerm Core.Lambda -> Phantoms.TTerm (Maybe Core.Type) -lambdaDomain x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Lambda"), - Core.projectionField = (Core.Name "domain")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -lambdaParameter :: Phantoms.TTerm Core.Lambda -> Phantoms.TTerm Core.Name -lambdaParameter x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Lambda"), - Core.projectionField = (Core.Name "parameter")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -lambdaWithBody :: Phantoms.TTerm Core.Lambda -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Core.Lambda -lambdaWithBody original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Lambda"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "parameter"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Lambda"), - Core.projectionField = (Core.Name "parameter")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "domain"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Lambda"), - Core.projectionField = (Core.Name "domain")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -lambdaWithDomain :: Phantoms.TTerm Core.Lambda -> Phantoms.TTerm (Maybe Core.Type) -> Phantoms.TTerm Core.Lambda -lambdaWithDomain original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Lambda"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "parameter"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Lambda"), - Core.projectionField = (Core.Name "parameter")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "domain"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Lambda"), - Core.projectionField = (Core.Name "body")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -lambdaWithParameter :: Phantoms.TTerm Core.Lambda -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core.Lambda -lambdaWithParameter original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Lambda"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "parameter"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "domain"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Lambda"), - Core.projectionField = (Core.Name "domain")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Lambda"), - Core.projectionField = (Core.Name "body")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -let_ :: Phantoms.TTerm [Core.Binding] -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Core.Let -let_ bindings body = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Let"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "bindings"), - Core.fieldTerm = (Phantoms.unTTerm bindings)}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Phantoms.unTTerm body)}]})) - -letBindings :: Phantoms.TTerm Core.Let -> Phantoms.TTerm [Core.Binding] -letBindings x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Let"), - Core.projectionField = (Core.Name "bindings")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -letBody :: Phantoms.TTerm Core.Let -> Phantoms.TTerm Core.Term -letBody x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Let"), - Core.projectionField = (Core.Name "body")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -letWithBindings :: Phantoms.TTerm Core.Let -> Phantoms.TTerm [Core.Binding] -> Phantoms.TTerm Core.Let -letWithBindings original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Let"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "bindings"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Let"), - Core.projectionField = (Core.Name "body")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -letWithBody :: Phantoms.TTerm Core.Let -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Core.Let -letWithBody original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Let"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "bindings"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Let"), - Core.projectionField = (Core.Name "bindings")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -literalBinary :: Phantoms.TTerm B.ByteString -> Phantoms.TTerm Core.Literal -literalBinary x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "binary"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -literalBoolean :: Phantoms.TTerm Bool -> Phantoms.TTerm Core.Literal -literalBoolean x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "boolean"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -literalFloat :: Phantoms.TTerm Core.FloatValue -> Phantoms.TTerm Core.Literal -literalFloat x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "float"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -literalInteger :: Phantoms.TTerm Core.IntegerValue -> Phantoms.TTerm Core.Literal -literalInteger x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -literalString :: Phantoms.TTerm String -> Phantoms.TTerm Core.Literal -literalString x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -literalTypeBinary :: Phantoms.TTerm Core.LiteralType -literalTypeBinary = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.LiteralType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "binary"), - Core.fieldTerm = Core.TermUnit}})) - -literalTypeBoolean :: Phantoms.TTerm Core.LiteralType -literalTypeBoolean = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.LiteralType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "boolean"), - Core.fieldTerm = Core.TermUnit}})) - -literalTypeFloat :: Phantoms.TTerm Core.FloatType -> Phantoms.TTerm Core.LiteralType -literalTypeFloat x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.LiteralType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "float"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -literalTypeInteger :: Phantoms.TTerm Core.IntegerType -> Phantoms.TTerm Core.LiteralType -literalTypeInteger x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.LiteralType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -literalTypeString :: Phantoms.TTerm Core.LiteralType -literalTypeString = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.LiteralType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = Core.TermUnit}})) - -mapType :: Phantoms.TTerm Core.Type -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Core.MapType -mapType keys values = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.MapType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "keys"), - Core.fieldTerm = (Phantoms.unTTerm keys)}, - Core.Field { - Core.fieldName = (Core.Name "values"), - Core.fieldTerm = (Phantoms.unTTerm values)}]})) - -mapTypeKeys :: Phantoms.TTerm Core.MapType -> Phantoms.TTerm Core.Type -mapTypeKeys x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.MapType"), - Core.projectionField = (Core.Name "keys")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -mapTypeValues :: Phantoms.TTerm Core.MapType -> Phantoms.TTerm Core.Type -mapTypeValues x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.MapType"), - Core.projectionField = (Core.Name "values")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -mapTypeWithKeys :: Phantoms.TTerm Core.MapType -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Core.MapType -mapTypeWithKeys original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.MapType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "keys"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "values"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.MapType"), - Core.projectionField = (Core.Name "values")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -mapTypeWithValues :: Phantoms.TTerm Core.MapType -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Core.MapType -mapTypeWithValues original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.MapType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "keys"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.MapType"), - Core.projectionField = (Core.Name "keys")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "values"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -name :: Phantoms.TTerm String -> Phantoms.TTerm Core.Name -name x = - Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Phantoms.unTTerm x)})) - -pairType :: Phantoms.TTerm Core.Type -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Core.PairType -pairType first second = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.PairType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "first"), - Core.fieldTerm = (Phantoms.unTTerm first)}, - Core.Field { - Core.fieldName = (Core.Name "second"), - Core.fieldTerm = (Phantoms.unTTerm second)}]})) - -pairTypeFirst :: Phantoms.TTerm Core.PairType -> Phantoms.TTerm Core.Type -pairTypeFirst x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.PairType"), - Core.projectionField = (Core.Name "first")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -pairTypeSecond :: Phantoms.TTerm Core.PairType -> Phantoms.TTerm Core.Type -pairTypeSecond x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.PairType"), - Core.projectionField = (Core.Name "second")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -pairTypeWithFirst :: Phantoms.TTerm Core.PairType -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Core.PairType -pairTypeWithFirst original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.PairType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "first"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "second"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.PairType"), - Core.projectionField = (Core.Name "second")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -pairTypeWithSecond :: Phantoms.TTerm Core.PairType -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Core.PairType -pairTypeWithSecond original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.PairType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "first"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.PairType"), - Core.projectionField = (Core.Name "first")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "second"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -projection :: Phantoms.TTerm Core.Name -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core.Projection -projection typeName field = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Projection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Phantoms.unTTerm typeName)}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Phantoms.unTTerm field)}]})) - -projectionField :: Phantoms.TTerm Core.Projection -> Phantoms.TTerm Core.Name -projectionField x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Projection"), - Core.projectionField = (Core.Name "field")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -projectionTypeName :: Phantoms.TTerm Core.Projection -> Phantoms.TTerm Core.Name -projectionTypeName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Projection"), - Core.projectionField = (Core.Name "typeName")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -projectionWithField :: Phantoms.TTerm Core.Projection -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core.Projection -projectionWithField original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Projection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Projection"), - Core.projectionField = (Core.Name "typeName")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -projectionWithTypeName :: Phantoms.TTerm Core.Projection -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core.Projection -projectionWithTypeName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Projection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Projection"), - Core.projectionField = (Core.Name "field")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -record :: Phantoms.TTerm Core.Name -> Phantoms.TTerm [Core.Field] -> Phantoms.TTerm Core.Record -record typeName fields = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Phantoms.unTTerm typeName)}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Phantoms.unTTerm fields)}]})) - -recordFields :: Phantoms.TTerm Core.Record -> Phantoms.TTerm [Core.Field] -recordFields x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Record"), - Core.projectionField = (Core.Name "fields")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -recordTypeName :: Phantoms.TTerm Core.Record -> Phantoms.TTerm Core.Name -recordTypeName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Record"), - Core.projectionField = (Core.Name "typeName")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -recordWithFields :: Phantoms.TTerm Core.Record -> Phantoms.TTerm [Core.Field] -> Phantoms.TTerm Core.Record -recordWithFields original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Record"), - Core.projectionField = (Core.Name "typeName")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -recordWithTypeName :: Phantoms.TTerm Core.Record -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core.Record -recordWithTypeName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Record"), - Core.projectionField = (Core.Name "fields")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -termAnnotated :: Phantoms.TTerm Core.AnnotatedTerm -> Phantoms.TTerm Core.Term -termAnnotated x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "annotated"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -termApplication :: Phantoms.TTerm Core.Application -> Phantoms.TTerm Core.Term -termApplication x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "application"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -termEither :: Phantoms.TTerm (Either Core.Term Core.Term) -> Phantoms.TTerm Core.Term -termEither x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "either"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -termFunction :: Phantoms.TTerm Core.Function -> Phantoms.TTerm Core.Term -termFunction x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "function"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -termLet :: Phantoms.TTerm Core.Let -> Phantoms.TTerm Core.Term -termLet x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "let"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -termList :: Phantoms.TTerm [Core.Term] -> Phantoms.TTerm Core.Term -termList x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -termLiteral :: Phantoms.TTerm Core.Literal -> Phantoms.TTerm Core.Term -termLiteral x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -termMap :: Phantoms.TTerm (M.Map Core.Term Core.Term) -> Phantoms.TTerm Core.Term -termMap x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "map"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -termMaybe :: Phantoms.TTerm (Maybe Core.Term) -> Phantoms.TTerm Core.Term -termMaybe x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "maybe"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -termPair :: Phantoms.TTerm (Core.Term, Core.Term) -> Phantoms.TTerm Core.Term -termPair x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "pair"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -termRecord :: Phantoms.TTerm Core.Record -> Phantoms.TTerm Core.Term -termRecord x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -termSet :: Phantoms.TTerm (S.Set Core.Term) -> Phantoms.TTerm Core.Term -termSet x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "set"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -termTypeApplication :: Phantoms.TTerm Core.TypeApplicationTerm -> Phantoms.TTerm Core.Term -termTypeApplication x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "typeApplication"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -termTypeLambda :: Phantoms.TTerm Core.TypeLambda -> Phantoms.TTerm Core.Term -termTypeLambda x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "typeLambda"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -termUnion :: Phantoms.TTerm Core.Injection -> Phantoms.TTerm Core.Term -termUnion x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "union"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -termUnit :: Phantoms.TTerm Core.Term -termUnit = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}})) - -termVariable :: Phantoms.TTerm Core.Name -> Phantoms.TTerm Core.Term -termVariable x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "variable"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -termWrap :: Phantoms.TTerm Core.WrappedTerm -> Phantoms.TTerm Core.Term -termWrap x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wrap"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -typeAnnotated :: Phantoms.TTerm Core.AnnotatedType -> Phantoms.TTerm Core.Type -typeAnnotated x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "annotated"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -typeApplication :: Phantoms.TTerm Core.ApplicationType -> Phantoms.TTerm Core.Type -typeApplication x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "application"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -typeApplicationTerm :: Phantoms.TTerm Core.Term -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Core.TypeApplicationTerm -typeApplicationTerm body type_ = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.TypeApplicationTerm"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Phantoms.unTTerm body)}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Phantoms.unTTerm type_)}]})) - -typeApplicationTermBody :: Phantoms.TTerm Core.TypeApplicationTerm -> Phantoms.TTerm Core.Term -typeApplicationTermBody x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.TypeApplicationTerm"), - Core.projectionField = (Core.Name "body")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -typeApplicationTermType :: Phantoms.TTerm Core.TypeApplicationTerm -> Phantoms.TTerm Core.Type -typeApplicationTermType x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.TypeApplicationTerm"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -typeApplicationTermWithBody :: Phantoms.TTerm Core.TypeApplicationTerm -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Core.TypeApplicationTerm -typeApplicationTermWithBody original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.TypeApplicationTerm"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.TypeApplicationTerm"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -typeApplicationTermWithType :: Phantoms.TTerm Core.TypeApplicationTerm -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Core.TypeApplicationTerm -typeApplicationTermWithType original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.TypeApplicationTerm"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.TypeApplicationTerm"), - Core.projectionField = (Core.Name "body")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -typeEither :: Phantoms.TTerm Core.EitherType -> Phantoms.TTerm Core.Type -typeEither x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "either"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -typeForall :: Phantoms.TTerm Core.ForallType -> Phantoms.TTerm Core.Type -typeForall x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "forall"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -typeFunction :: Phantoms.TTerm Core.FunctionType -> Phantoms.TTerm Core.Type -typeFunction x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "function"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -typeLambda :: Phantoms.TTerm Core.Name -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Core.TypeLambda -typeLambda parameter body = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.TypeLambda"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "parameter"), - Core.fieldTerm = (Phantoms.unTTerm parameter)}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Phantoms.unTTerm body)}]})) - -typeLambdaBody :: Phantoms.TTerm Core.TypeLambda -> Phantoms.TTerm Core.Term -typeLambdaBody x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.TypeLambda"), - Core.projectionField = (Core.Name "body")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -typeLambdaParameter :: Phantoms.TTerm Core.TypeLambda -> Phantoms.TTerm Core.Name -typeLambdaParameter x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.TypeLambda"), - Core.projectionField = (Core.Name "parameter")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -typeLambdaWithBody :: Phantoms.TTerm Core.TypeLambda -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Core.TypeLambda -typeLambdaWithBody original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.TypeLambda"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "parameter"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.TypeLambda"), - Core.projectionField = (Core.Name "parameter")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -typeLambdaWithParameter :: Phantoms.TTerm Core.TypeLambda -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core.TypeLambda -typeLambdaWithParameter original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.TypeLambda"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "parameter"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.TypeLambda"), - Core.projectionField = (Core.Name "body")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -typeList :: Phantoms.TTerm Core.Type -> Phantoms.TTerm Core.Type -typeList x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -typeLiteral :: Phantoms.TTerm Core.LiteralType -> Phantoms.TTerm Core.Type -typeLiteral x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -typeMap :: Phantoms.TTerm Core.MapType -> Phantoms.TTerm Core.Type -typeMap x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "map"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -typeMaybe :: Phantoms.TTerm Core.Type -> Phantoms.TTerm Core.Type -typeMaybe x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "maybe"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -typePair :: Phantoms.TTerm Core.PairType -> Phantoms.TTerm Core.Type -typePair x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "pair"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -typeRecord :: Phantoms.TTerm [Core.FieldType] -> Phantoms.TTerm Core.Type -typeRecord x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -typeScheme :: Phantoms.TTerm [Core.Name] -> Phantoms.TTerm Core.Type -> Phantoms.TTerm (Maybe (M.Map Core.Name Core.TypeVariableMetadata)) -> Phantoms.TTerm Core.TypeScheme -typeScheme variables type_ constraints = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.TypeScheme"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "variables"), - Core.fieldTerm = (Phantoms.unTTerm variables)}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Phantoms.unTTerm type_)}, - Core.Field { - Core.fieldName = (Core.Name "constraints"), - Core.fieldTerm = (Phantoms.unTTerm constraints)}]})) - -typeSchemeConstraints :: Phantoms.TTerm Core.TypeScheme -> Phantoms.TTerm (Maybe (M.Map Core.Name Core.TypeVariableMetadata)) -typeSchemeConstraints x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.TypeScheme"), - Core.projectionField = (Core.Name "constraints")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -typeSchemeType :: Phantoms.TTerm Core.TypeScheme -> Phantoms.TTerm Core.Type -typeSchemeType x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.TypeScheme"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -typeSchemeVariables :: Phantoms.TTerm Core.TypeScheme -> Phantoms.TTerm [Core.Name] -typeSchemeVariables x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.TypeScheme"), - Core.projectionField = (Core.Name "variables")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -typeSchemeWithConstraints :: Phantoms.TTerm Core.TypeScheme -> Phantoms.TTerm (Maybe (M.Map Core.Name Core.TypeVariableMetadata)) -> Phantoms.TTerm Core.TypeScheme -typeSchemeWithConstraints original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.TypeScheme"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "variables"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.TypeScheme"), - Core.projectionField = (Core.Name "variables")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.TypeScheme"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "constraints"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -typeSchemeWithType :: Phantoms.TTerm Core.TypeScheme -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Core.TypeScheme -typeSchemeWithType original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.TypeScheme"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "variables"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.TypeScheme"), - Core.projectionField = (Core.Name "variables")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "constraints"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.TypeScheme"), - Core.projectionField = (Core.Name "constraints")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -typeSchemeWithVariables :: Phantoms.TTerm Core.TypeScheme -> Phantoms.TTerm [Core.Name] -> Phantoms.TTerm Core.TypeScheme -typeSchemeWithVariables original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.TypeScheme"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "variables"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.TypeScheme"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "constraints"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.TypeScheme"), - Core.projectionField = (Core.Name "constraints")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -typeSet :: Phantoms.TTerm Core.Type -> Phantoms.TTerm Core.Type -typeSet x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "set"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -typeUnion :: Phantoms.TTerm [Core.FieldType] -> Phantoms.TTerm Core.Type -typeUnion x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "union"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -typeUnit :: Phantoms.TTerm Core.Type -typeUnit = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}})) - -typeVariable :: Phantoms.TTerm Core.Name -> Phantoms.TTerm Core.Type -typeVariable x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "variable"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -typeVariableMetadata :: Phantoms.TTerm (S.Set Core.Name) -> Phantoms.TTerm Core.TypeVariableMetadata -typeVariableMetadata classes = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.TypeVariableMetadata"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "classes"), - Core.fieldTerm = (Phantoms.unTTerm classes)}]})) - -typeVariableMetadataClasses :: Phantoms.TTerm Core.TypeVariableMetadata -> Phantoms.TTerm (S.Set Core.Name) -typeVariableMetadataClasses x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.TypeVariableMetadata"), - Core.projectionField = (Core.Name "classes")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -typeVariableMetadataWithClasses :: Phantoms.TTerm Core.TypeVariableMetadata -> Phantoms.TTerm (S.Set Core.Name) -> Phantoms.TTerm Core.TypeVariableMetadata -typeVariableMetadataWithClasses original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.TypeVariableMetadata"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "classes"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -typeVoid :: Phantoms.TTerm Core.Type -typeVoid = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "void"), - Core.fieldTerm = Core.TermUnit}})) - -typeWrap :: Phantoms.TTerm Core.Type -> Phantoms.TTerm Core.Type -typeWrap x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wrap"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -unName :: Phantoms.TTerm Core.Name -> Phantoms.TTerm String -unName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.core.Name")))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -wrappedTerm :: Phantoms.TTerm Core.Name -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Core.WrappedTerm -wrappedTerm typeName body = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Phantoms.unTTerm typeName)}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Phantoms.unTTerm body)}]})) - -wrappedTermBody :: Phantoms.TTerm Core.WrappedTerm -> Phantoms.TTerm Core.Term -wrappedTermBody x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.projectionField = (Core.Name "body")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -wrappedTermTypeName :: Phantoms.TTerm Core.WrappedTerm -> Phantoms.TTerm Core.Name -wrappedTermTypeName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.projectionField = (Core.Name "typeName")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -wrappedTermWithBody :: Phantoms.TTerm Core.WrappedTerm -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Core.WrappedTerm -wrappedTermWithBody original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.projectionField = (Core.Name "typeName")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -wrappedTermWithTypeName :: Phantoms.TTerm Core.WrappedTerm -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core.WrappedTerm -wrappedTermWithTypeName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.projectionField = (Core.Name "body")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) diff --git a/src/gen-main/haskell/Hydra/Dsl/Error/Checking.hs b/src/gen-main/haskell/Hydra/Dsl/Error/Checking.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Dsl/Error/Checking.hs +++ /dev/null @@ -1,617 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | DSL functions for hydra.error.checking - -module Hydra.Dsl.Error.Checking where - -import qualified Hydra.Core as Core -import qualified Hydra.Error.Checking as Checking -import qualified Hydra.Phantoms as Phantoms -import qualified Hydra.Typing as Typing -import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -checkingErrorIncorrectUnification :: Phantoms.TTerm Checking.IncorrectUnificationError -> Phantoms.TTerm Checking.CheckingError -checkingErrorIncorrectUnification x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "incorrectUnification"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -checkingErrorNotAForallType :: Phantoms.TTerm Checking.NotAForallTypeError -> Phantoms.TTerm Checking.CheckingError -checkingErrorNotAForallType x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "notAForallType"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -checkingErrorNotAFunctionType :: Phantoms.TTerm Checking.NotAFunctionTypeError -> Phantoms.TTerm Checking.CheckingError -checkingErrorNotAFunctionType x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "notAFunctionType"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -checkingErrorTypeArityMismatch :: Phantoms.TTerm Checking.TypeArityMismatchError -> Phantoms.TTerm Checking.CheckingError -checkingErrorTypeArityMismatch x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "typeArityMismatch"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -checkingErrorTypeMismatch :: Phantoms.TTerm Checking.TypeMismatchError -> Phantoms.TTerm Checking.CheckingError -checkingErrorTypeMismatch x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "typeMismatch"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -checkingErrorUnboundTypeVariables :: Phantoms.TTerm Checking.UnboundTypeVariablesError -> Phantoms.TTerm Checking.CheckingError -checkingErrorUnboundTypeVariables x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unboundTypeVariables"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -checkingErrorUnequalTypes :: Phantoms.TTerm Checking.UnequalTypesError -> Phantoms.TTerm Checking.CheckingError -checkingErrorUnequalTypes x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unequalTypes"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -checkingErrorUnsupportedTermVariant :: Phantoms.TTerm Checking.UnsupportedTermVariantError -> Phantoms.TTerm Checking.CheckingError -checkingErrorUnsupportedTermVariant x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unsupportedTermVariant"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -checkingErrorUntypedLambda :: Phantoms.TTerm Checking.UntypedLambdaError -> Phantoms.TTerm Checking.CheckingError -checkingErrorUntypedLambda x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "untypedLambda"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -checkingErrorUntypedLetBinding :: Phantoms.TTerm Checking.UntypedLetBindingError -> Phantoms.TTerm Checking.CheckingError -checkingErrorUntypedLetBinding x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "untypedLetBinding"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -incorrectUnificationError :: Phantoms.TTerm Typing.TypeSubst -> Phantoms.TTerm Checking.IncorrectUnificationError -incorrectUnificationError substitution = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.IncorrectUnificationError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "substitution"), - Core.fieldTerm = (Phantoms.unTTerm substitution)}]})) - -incorrectUnificationErrorSubstitution :: Phantoms.TTerm Checking.IncorrectUnificationError -> Phantoms.TTerm Typing.TypeSubst -incorrectUnificationErrorSubstitution x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.IncorrectUnificationError"), - Core.projectionField = (Core.Name "substitution")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -incorrectUnificationErrorWithSubstitution :: Phantoms.TTerm Checking.IncorrectUnificationError -> Phantoms.TTerm Typing.TypeSubst -> Phantoms.TTerm Checking.IncorrectUnificationError -incorrectUnificationErrorWithSubstitution original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.IncorrectUnificationError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "substitution"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -notAForallTypeError :: Phantoms.TTerm Core.Type -> Phantoms.TTerm [Core.Type] -> Phantoms.TTerm Checking.NotAForallTypeError -notAForallTypeError type_ typeArguments = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.NotAForallTypeError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Phantoms.unTTerm type_)}, - Core.Field { - Core.fieldName = (Core.Name "typeArguments"), - Core.fieldTerm = (Phantoms.unTTerm typeArguments)}]})) - -notAForallTypeErrorType :: Phantoms.TTerm Checking.NotAForallTypeError -> Phantoms.TTerm Core.Type -notAForallTypeErrorType x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.NotAForallTypeError"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -notAForallTypeErrorTypeArguments :: Phantoms.TTerm Checking.NotAForallTypeError -> Phantoms.TTerm [Core.Type] -notAForallTypeErrorTypeArguments x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.NotAForallTypeError"), - Core.projectionField = (Core.Name "typeArguments")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -notAForallTypeErrorWithType :: Phantoms.TTerm Checking.NotAForallTypeError -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Checking.NotAForallTypeError -notAForallTypeErrorWithType original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.NotAForallTypeError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "typeArguments"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.NotAForallTypeError"), - Core.projectionField = (Core.Name "typeArguments")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -notAForallTypeErrorWithTypeArguments :: Phantoms.TTerm Checking.NotAForallTypeError -> Phantoms.TTerm [Core.Type] -> Phantoms.TTerm Checking.NotAForallTypeError -notAForallTypeErrorWithTypeArguments original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.NotAForallTypeError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.NotAForallTypeError"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "typeArguments"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -notAFunctionTypeError :: Phantoms.TTerm Core.Type -> Phantoms.TTerm Checking.NotAFunctionTypeError -notAFunctionTypeError type_ = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.NotAFunctionTypeError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Phantoms.unTTerm type_)}]})) - -notAFunctionTypeErrorType :: Phantoms.TTerm Checking.NotAFunctionTypeError -> Phantoms.TTerm Core.Type -notAFunctionTypeErrorType x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.NotAFunctionTypeError"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -notAFunctionTypeErrorWithType :: Phantoms.TTerm Checking.NotAFunctionTypeError -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Checking.NotAFunctionTypeError -notAFunctionTypeErrorWithType original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.NotAFunctionTypeError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -typeArityMismatchError :: Phantoms.TTerm Core.Type -> Phantoms.TTerm Int -> Phantoms.TTerm Int -> Phantoms.TTerm [Core.Type] -> Phantoms.TTerm Checking.TypeArityMismatchError -typeArityMismatchError type_ expectedArity actualArity typeArguments = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.TypeArityMismatchError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Phantoms.unTTerm type_)}, - Core.Field { - Core.fieldName = (Core.Name "expectedArity"), - Core.fieldTerm = (Phantoms.unTTerm expectedArity)}, - Core.Field { - Core.fieldName = (Core.Name "actualArity"), - Core.fieldTerm = (Phantoms.unTTerm actualArity)}, - Core.Field { - Core.fieldName = (Core.Name "typeArguments"), - Core.fieldTerm = (Phantoms.unTTerm typeArguments)}]})) - -typeArityMismatchErrorActualArity :: Phantoms.TTerm Checking.TypeArityMismatchError -> Phantoms.TTerm Int -typeArityMismatchErrorActualArity x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.TypeArityMismatchError"), - Core.projectionField = (Core.Name "actualArity")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -typeArityMismatchErrorExpectedArity :: Phantoms.TTerm Checking.TypeArityMismatchError -> Phantoms.TTerm Int -typeArityMismatchErrorExpectedArity x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.TypeArityMismatchError"), - Core.projectionField = (Core.Name "expectedArity")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -typeArityMismatchErrorType :: Phantoms.TTerm Checking.TypeArityMismatchError -> Phantoms.TTerm Core.Type -typeArityMismatchErrorType x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.TypeArityMismatchError"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -typeArityMismatchErrorTypeArguments :: Phantoms.TTerm Checking.TypeArityMismatchError -> Phantoms.TTerm [Core.Type] -typeArityMismatchErrorTypeArguments x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.TypeArityMismatchError"), - Core.projectionField = (Core.Name "typeArguments")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -typeArityMismatchErrorWithActualArity :: Phantoms.TTerm Checking.TypeArityMismatchError -> Phantoms.TTerm Int -> Phantoms.TTerm Checking.TypeArityMismatchError -typeArityMismatchErrorWithActualArity original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.TypeArityMismatchError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.TypeArityMismatchError"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "expectedArity"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.TypeArityMismatchError"), - Core.projectionField = (Core.Name "expectedArity")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "actualArity"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "typeArguments"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.TypeArityMismatchError"), - Core.projectionField = (Core.Name "typeArguments")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -typeArityMismatchErrorWithExpectedArity :: Phantoms.TTerm Checking.TypeArityMismatchError -> Phantoms.TTerm Int -> Phantoms.TTerm Checking.TypeArityMismatchError -typeArityMismatchErrorWithExpectedArity original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.TypeArityMismatchError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.TypeArityMismatchError"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "expectedArity"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "actualArity"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.TypeArityMismatchError"), - Core.projectionField = (Core.Name "actualArity")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "typeArguments"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.TypeArityMismatchError"), - Core.projectionField = (Core.Name "typeArguments")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -typeArityMismatchErrorWithType :: Phantoms.TTerm Checking.TypeArityMismatchError -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Checking.TypeArityMismatchError -typeArityMismatchErrorWithType original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.TypeArityMismatchError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "expectedArity"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.TypeArityMismatchError"), - Core.projectionField = (Core.Name "expectedArity")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "actualArity"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.TypeArityMismatchError"), - Core.projectionField = (Core.Name "actualArity")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "typeArguments"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.TypeArityMismatchError"), - Core.projectionField = (Core.Name "typeArguments")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -typeArityMismatchErrorWithTypeArguments :: Phantoms.TTerm Checking.TypeArityMismatchError -> Phantoms.TTerm [Core.Type] -> Phantoms.TTerm Checking.TypeArityMismatchError -typeArityMismatchErrorWithTypeArguments original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.TypeArityMismatchError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.TypeArityMismatchError"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "expectedArity"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.TypeArityMismatchError"), - Core.projectionField = (Core.Name "expectedArity")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "actualArity"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.TypeArityMismatchError"), - Core.projectionField = (Core.Name "actualArity")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "typeArguments"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -typeMismatchError :: Phantoms.TTerm Core.Type -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Checking.TypeMismatchError -typeMismatchError expectedType actualType = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.TypeMismatchError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "expectedType"), - Core.fieldTerm = (Phantoms.unTTerm expectedType)}, - Core.Field { - Core.fieldName = (Core.Name "actualType"), - Core.fieldTerm = (Phantoms.unTTerm actualType)}]})) - -typeMismatchErrorActualType :: Phantoms.TTerm Checking.TypeMismatchError -> Phantoms.TTerm Core.Type -typeMismatchErrorActualType x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.TypeMismatchError"), - Core.projectionField = (Core.Name "actualType")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -typeMismatchErrorExpectedType :: Phantoms.TTerm Checking.TypeMismatchError -> Phantoms.TTerm Core.Type -typeMismatchErrorExpectedType x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.TypeMismatchError"), - Core.projectionField = (Core.Name "expectedType")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -typeMismatchErrorWithActualType :: Phantoms.TTerm Checking.TypeMismatchError -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Checking.TypeMismatchError -typeMismatchErrorWithActualType original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.TypeMismatchError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "expectedType"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.TypeMismatchError"), - Core.projectionField = (Core.Name "expectedType")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "actualType"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -typeMismatchErrorWithExpectedType :: Phantoms.TTerm Checking.TypeMismatchError -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Checking.TypeMismatchError -typeMismatchErrorWithExpectedType original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.TypeMismatchError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "expectedType"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "actualType"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.TypeMismatchError"), - Core.projectionField = (Core.Name "actualType")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -unboundTypeVariablesError :: Phantoms.TTerm (S.Set Core.Name) -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Checking.UnboundTypeVariablesError -unboundTypeVariablesError variables type_ = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.UnboundTypeVariablesError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "variables"), - Core.fieldTerm = (Phantoms.unTTerm variables)}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Phantoms.unTTerm type_)}]})) - -unboundTypeVariablesErrorType :: Phantoms.TTerm Checking.UnboundTypeVariablesError -> Phantoms.TTerm Core.Type -unboundTypeVariablesErrorType x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.UnboundTypeVariablesError"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -unboundTypeVariablesErrorVariables :: Phantoms.TTerm Checking.UnboundTypeVariablesError -> Phantoms.TTerm (S.Set Core.Name) -unboundTypeVariablesErrorVariables x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.UnboundTypeVariablesError"), - Core.projectionField = (Core.Name "variables")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -unboundTypeVariablesErrorWithType :: Phantoms.TTerm Checking.UnboundTypeVariablesError -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Checking.UnboundTypeVariablesError -unboundTypeVariablesErrorWithType original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.UnboundTypeVariablesError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "variables"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.UnboundTypeVariablesError"), - Core.projectionField = (Core.Name "variables")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -unboundTypeVariablesErrorWithVariables :: Phantoms.TTerm Checking.UnboundTypeVariablesError -> Phantoms.TTerm (S.Set Core.Name) -> Phantoms.TTerm Checking.UnboundTypeVariablesError -unboundTypeVariablesErrorWithVariables original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.UnboundTypeVariablesError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "variables"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.UnboundTypeVariablesError"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -unequalTypesError :: Phantoms.TTerm [Core.Type] -> Phantoms.TTerm String -> Phantoms.TTerm Checking.UnequalTypesError -unequalTypesError types description = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.UnequalTypesError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "types"), - Core.fieldTerm = (Phantoms.unTTerm types)}, - Core.Field { - Core.fieldName = (Core.Name "description"), - Core.fieldTerm = (Phantoms.unTTerm description)}]})) - -unequalTypesErrorDescription :: Phantoms.TTerm Checking.UnequalTypesError -> Phantoms.TTerm String -unequalTypesErrorDescription x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.UnequalTypesError"), - Core.projectionField = (Core.Name "description")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -unequalTypesErrorTypes :: Phantoms.TTerm Checking.UnequalTypesError -> Phantoms.TTerm [Core.Type] -unequalTypesErrorTypes x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.UnequalTypesError"), - Core.projectionField = (Core.Name "types")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -unequalTypesErrorWithDescription :: Phantoms.TTerm Checking.UnequalTypesError -> Phantoms.TTerm String -> Phantoms.TTerm Checking.UnequalTypesError -unequalTypesErrorWithDescription original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.UnequalTypesError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "types"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.UnequalTypesError"), - Core.projectionField = (Core.Name "types")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "description"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -unequalTypesErrorWithTypes :: Phantoms.TTerm Checking.UnequalTypesError -> Phantoms.TTerm [Core.Type] -> Phantoms.TTerm Checking.UnequalTypesError -unequalTypesErrorWithTypes original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.UnequalTypesError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "types"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "description"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.UnequalTypesError"), - Core.projectionField = (Core.Name "description")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -unsupportedTermVariantError :: Phantoms.TTerm Variants.TermVariant -> Phantoms.TTerm Checking.UnsupportedTermVariantError -unsupportedTermVariantError termVariant = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.UnsupportedTermVariantError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "termVariant"), - Core.fieldTerm = (Phantoms.unTTerm termVariant)}]})) - -unsupportedTermVariantErrorTermVariant :: Phantoms.TTerm Checking.UnsupportedTermVariantError -> Phantoms.TTerm Variants.TermVariant -unsupportedTermVariantErrorTermVariant x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.UnsupportedTermVariantError"), - Core.projectionField = (Core.Name "termVariant")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -unsupportedTermVariantErrorWithTermVariant :: Phantoms.TTerm Checking.UnsupportedTermVariantError -> Phantoms.TTerm Variants.TermVariant -> Phantoms.TTerm Checking.UnsupportedTermVariantError -unsupportedTermVariantErrorWithTermVariant original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.UnsupportedTermVariantError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "termVariant"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -untypedLambdaError :: Phantoms.TTerm Checking.UntypedLambdaError -untypedLambdaError = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.UntypedLambdaError"), - Core.recordFields = []})) - -untypedLetBindingError :: Phantoms.TTerm Core.Binding -> Phantoms.TTerm Checking.UntypedLetBindingError -untypedLetBindingError binding = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.UntypedLetBindingError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "binding"), - Core.fieldTerm = (Phantoms.unTTerm binding)}]})) - -untypedLetBindingErrorBinding :: Phantoms.TTerm Checking.UntypedLetBindingError -> Phantoms.TTerm Core.Binding -untypedLetBindingErrorBinding x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.checking.UntypedLetBindingError"), - Core.projectionField = (Core.Name "binding")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -untypedLetBindingErrorWithBinding :: Phantoms.TTerm Checking.UntypedLetBindingError -> Phantoms.TTerm Core.Binding -> Phantoms.TTerm Checking.UntypedLetBindingError -untypedLetBindingErrorWithBinding original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.UntypedLetBindingError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "binding"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) diff --git a/src/gen-main/haskell/Hydra/Dsl/Error/Core.hs b/src/gen-main/haskell/Hydra/Dsl/Error/Core.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Dsl/Error/Core.hs +++ /dev/null @@ -1,2305 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | DSL functions for hydra.error.core - -module Hydra.Dsl.Error.Core where - -import qualified Hydra.Core as Core -import qualified Hydra.Error.Core as Core_ -import qualified Hydra.Paths as Paths -import qualified Hydra.Phantoms as Phantoms -import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -constantConditionError :: Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Bool -> Phantoms.TTerm Core_.ConstantConditionError -constantConditionError location value = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.ConstantConditionError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm location)}, - Core.Field { - Core.fieldName = (Core.Name "value"), - Core.fieldTerm = (Phantoms.unTTerm value)}]})) - -constantConditionErrorLocation :: Phantoms.TTerm Core_.ConstantConditionError -> Phantoms.TTerm Paths.SubtermPath -constantConditionErrorLocation x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.ConstantConditionError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -constantConditionErrorValue :: Phantoms.TTerm Core_.ConstantConditionError -> Phantoms.TTerm Bool -constantConditionErrorValue x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.ConstantConditionError"), - Core.projectionField = (Core.Name "value")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -constantConditionErrorWithLocation :: Phantoms.TTerm Core_.ConstantConditionError -> Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core_.ConstantConditionError -constantConditionErrorWithLocation original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.ConstantConditionError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "value"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.ConstantConditionError"), - Core.projectionField = (Core.Name "value")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -constantConditionErrorWithValue :: Phantoms.TTerm Core_.ConstantConditionError -> Phantoms.TTerm Bool -> Phantoms.TTerm Core_.ConstantConditionError -constantConditionErrorWithValue original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.ConstantConditionError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.ConstantConditionError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "value"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -duplicateBindingError :: Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core_.DuplicateBindingError -duplicateBindingError location name = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.DuplicateBindingError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm location)}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm name)}]})) - -duplicateBindingErrorLocation :: Phantoms.TTerm Core_.DuplicateBindingError -> Phantoms.TTerm Paths.SubtermPath -duplicateBindingErrorLocation x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.DuplicateBindingError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -duplicateBindingErrorName :: Phantoms.TTerm Core_.DuplicateBindingError -> Phantoms.TTerm Core.Name -duplicateBindingErrorName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.DuplicateBindingError"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -duplicateBindingErrorWithLocation :: Phantoms.TTerm Core_.DuplicateBindingError -> Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core_.DuplicateBindingError -duplicateBindingErrorWithLocation original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.DuplicateBindingError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.DuplicateBindingError"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -duplicateBindingErrorWithName :: Phantoms.TTerm Core_.DuplicateBindingError -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core_.DuplicateBindingError -duplicateBindingErrorWithName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.DuplicateBindingError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.DuplicateBindingError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -duplicateFieldError :: Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core_.DuplicateFieldError -duplicateFieldError location name = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.DuplicateFieldError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm location)}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm name)}]})) - -duplicateFieldErrorLocation :: Phantoms.TTerm Core_.DuplicateFieldError -> Phantoms.TTerm Paths.SubtermPath -duplicateFieldErrorLocation x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.DuplicateFieldError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -duplicateFieldErrorName :: Phantoms.TTerm Core_.DuplicateFieldError -> Phantoms.TTerm Core.Name -duplicateFieldErrorName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.DuplicateFieldError"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -duplicateFieldErrorWithLocation :: Phantoms.TTerm Core_.DuplicateFieldError -> Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core_.DuplicateFieldError -duplicateFieldErrorWithLocation original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.DuplicateFieldError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.DuplicateFieldError"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -duplicateFieldErrorWithName :: Phantoms.TTerm Core_.DuplicateFieldError -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core_.DuplicateFieldError -duplicateFieldErrorWithName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.DuplicateFieldError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.DuplicateFieldError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -duplicateRecordTypeFieldNamesError :: Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core_.DuplicateRecordTypeFieldNamesError -duplicateRecordTypeFieldNamesError location name = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.DuplicateRecordTypeFieldNamesError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm location)}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm name)}]})) - -duplicateRecordTypeFieldNamesErrorLocation :: Phantoms.TTerm Core_.DuplicateRecordTypeFieldNamesError -> Phantoms.TTerm Paths.SubtermPath -duplicateRecordTypeFieldNamesErrorLocation x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.DuplicateRecordTypeFieldNamesError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -duplicateRecordTypeFieldNamesErrorName :: Phantoms.TTerm Core_.DuplicateRecordTypeFieldNamesError -> Phantoms.TTerm Core.Name -duplicateRecordTypeFieldNamesErrorName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.DuplicateRecordTypeFieldNamesError"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -duplicateRecordTypeFieldNamesErrorWithLocation :: Phantoms.TTerm Core_.DuplicateRecordTypeFieldNamesError -> Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core_.DuplicateRecordTypeFieldNamesError -duplicateRecordTypeFieldNamesErrorWithLocation original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.DuplicateRecordTypeFieldNamesError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.DuplicateRecordTypeFieldNamesError"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -duplicateRecordTypeFieldNamesErrorWithName :: Phantoms.TTerm Core_.DuplicateRecordTypeFieldNamesError -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core_.DuplicateRecordTypeFieldNamesError -duplicateRecordTypeFieldNamesErrorWithName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.DuplicateRecordTypeFieldNamesError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.DuplicateRecordTypeFieldNamesError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -duplicateUnionTypeFieldNamesError :: Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core_.DuplicateUnionTypeFieldNamesError -duplicateUnionTypeFieldNamesError location name = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.DuplicateUnionTypeFieldNamesError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm location)}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm name)}]})) - -duplicateUnionTypeFieldNamesErrorLocation :: Phantoms.TTerm Core_.DuplicateUnionTypeFieldNamesError -> Phantoms.TTerm Paths.SubtermPath -duplicateUnionTypeFieldNamesErrorLocation x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.DuplicateUnionTypeFieldNamesError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -duplicateUnionTypeFieldNamesErrorName :: Phantoms.TTerm Core_.DuplicateUnionTypeFieldNamesError -> Phantoms.TTerm Core.Name -duplicateUnionTypeFieldNamesErrorName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.DuplicateUnionTypeFieldNamesError"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -duplicateUnionTypeFieldNamesErrorWithLocation :: Phantoms.TTerm Core_.DuplicateUnionTypeFieldNamesError -> Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core_.DuplicateUnionTypeFieldNamesError -duplicateUnionTypeFieldNamesErrorWithLocation original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.DuplicateUnionTypeFieldNamesError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.DuplicateUnionTypeFieldNamesError"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -duplicateUnionTypeFieldNamesErrorWithName :: Phantoms.TTerm Core_.DuplicateUnionTypeFieldNamesError -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core_.DuplicateUnionTypeFieldNamesError -duplicateUnionTypeFieldNamesErrorWithName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.DuplicateUnionTypeFieldNamesError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.DuplicateUnionTypeFieldNamesError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -emptyCaseStatementError :: Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core_.EmptyCaseStatementError -emptyCaseStatementError location typeName = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.EmptyCaseStatementError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm location)}, - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Phantoms.unTTerm typeName)}]})) - -emptyCaseStatementErrorLocation :: Phantoms.TTerm Core_.EmptyCaseStatementError -> Phantoms.TTerm Paths.SubtermPath -emptyCaseStatementErrorLocation x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.EmptyCaseStatementError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -emptyCaseStatementErrorTypeName :: Phantoms.TTerm Core_.EmptyCaseStatementError -> Phantoms.TTerm Core.Name -emptyCaseStatementErrorTypeName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.EmptyCaseStatementError"), - Core.projectionField = (Core.Name "typeName")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -emptyCaseStatementErrorWithLocation :: Phantoms.TTerm Core_.EmptyCaseStatementError -> Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core_.EmptyCaseStatementError -emptyCaseStatementErrorWithLocation original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.EmptyCaseStatementError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.EmptyCaseStatementError"), - Core.projectionField = (Core.Name "typeName")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -emptyCaseStatementErrorWithTypeName :: Phantoms.TTerm Core_.EmptyCaseStatementError -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core_.EmptyCaseStatementError -emptyCaseStatementErrorWithTypeName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.EmptyCaseStatementError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.EmptyCaseStatementError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -emptyLetBindingsError :: Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core_.EmptyLetBindingsError -emptyLetBindingsError location = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.EmptyLetBindingsError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm location)}]})) - -emptyLetBindingsErrorLocation :: Phantoms.TTerm Core_.EmptyLetBindingsError -> Phantoms.TTerm Paths.SubtermPath -emptyLetBindingsErrorLocation x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.EmptyLetBindingsError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -emptyLetBindingsErrorWithLocation :: Phantoms.TTerm Core_.EmptyLetBindingsError -> Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core_.EmptyLetBindingsError -emptyLetBindingsErrorWithLocation original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.EmptyLetBindingsError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -emptyRecordTypeError :: Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core_.EmptyRecordTypeError -emptyRecordTypeError location = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.EmptyRecordTypeError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm location)}]})) - -emptyRecordTypeErrorLocation :: Phantoms.TTerm Core_.EmptyRecordTypeError -> Phantoms.TTerm Paths.SubtermPath -emptyRecordTypeErrorLocation x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.EmptyRecordTypeError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -emptyRecordTypeErrorWithLocation :: Phantoms.TTerm Core_.EmptyRecordTypeError -> Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core_.EmptyRecordTypeError -emptyRecordTypeErrorWithLocation original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.EmptyRecordTypeError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -emptyTermAnnotationError :: Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core_.EmptyTermAnnotationError -emptyTermAnnotationError location = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.EmptyTermAnnotationError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm location)}]})) - -emptyTermAnnotationErrorLocation :: Phantoms.TTerm Core_.EmptyTermAnnotationError -> Phantoms.TTerm Paths.SubtermPath -emptyTermAnnotationErrorLocation x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.EmptyTermAnnotationError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -emptyTermAnnotationErrorWithLocation :: Phantoms.TTerm Core_.EmptyTermAnnotationError -> Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core_.EmptyTermAnnotationError -emptyTermAnnotationErrorWithLocation original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.EmptyTermAnnotationError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -emptyTypeAnnotationError :: Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core_.EmptyTypeAnnotationError -emptyTypeAnnotationError location = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.EmptyTypeAnnotationError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm location)}]})) - -emptyTypeAnnotationErrorLocation :: Phantoms.TTerm Core_.EmptyTypeAnnotationError -> Phantoms.TTerm Paths.SubtermPath -emptyTypeAnnotationErrorLocation x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.EmptyTypeAnnotationError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -emptyTypeAnnotationErrorWithLocation :: Phantoms.TTerm Core_.EmptyTypeAnnotationError -> Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core_.EmptyTypeAnnotationError -emptyTypeAnnotationErrorWithLocation original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.EmptyTypeAnnotationError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -emptyTypeNameInTermError :: Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core_.EmptyTypeNameInTermError -emptyTypeNameInTermError location = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.EmptyTypeNameInTermError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm location)}]})) - -emptyTypeNameInTermErrorLocation :: Phantoms.TTerm Core_.EmptyTypeNameInTermError -> Phantoms.TTerm Paths.SubtermPath -emptyTypeNameInTermErrorLocation x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.EmptyTypeNameInTermError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -emptyTypeNameInTermErrorWithLocation :: Phantoms.TTerm Core_.EmptyTypeNameInTermError -> Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core_.EmptyTypeNameInTermError -emptyTypeNameInTermErrorWithLocation original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.EmptyTypeNameInTermError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -emptyUnionTypeError :: Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core_.EmptyUnionTypeError -emptyUnionTypeError location = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.EmptyUnionTypeError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm location)}]})) - -emptyUnionTypeErrorLocation :: Phantoms.TTerm Core_.EmptyUnionTypeError -> Phantoms.TTerm Paths.SubtermPath -emptyUnionTypeErrorLocation x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.EmptyUnionTypeError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -emptyUnionTypeErrorWithLocation :: Phantoms.TTerm Core_.EmptyUnionTypeError -> Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core_.EmptyUnionTypeError -emptyUnionTypeErrorWithLocation original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.EmptyUnionTypeError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -invalidForallParameterNameError :: Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core_.InvalidForallParameterNameError -invalidForallParameterNameError location name = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.InvalidForallParameterNameError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm location)}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm name)}]})) - -invalidForallParameterNameErrorLocation :: Phantoms.TTerm Core_.InvalidForallParameterNameError -> Phantoms.TTerm Paths.SubtermPath -invalidForallParameterNameErrorLocation x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidForallParameterNameError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -invalidForallParameterNameErrorName :: Phantoms.TTerm Core_.InvalidForallParameterNameError -> Phantoms.TTerm Core.Name -invalidForallParameterNameErrorName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidForallParameterNameError"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -invalidForallParameterNameErrorWithLocation :: Phantoms.TTerm Core_.InvalidForallParameterNameError -> Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core_.InvalidForallParameterNameError -invalidForallParameterNameErrorWithLocation original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.InvalidForallParameterNameError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidForallParameterNameError"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -invalidForallParameterNameErrorWithName :: Phantoms.TTerm Core_.InvalidForallParameterNameError -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core_.InvalidForallParameterNameError -invalidForallParameterNameErrorWithName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.InvalidForallParameterNameError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidForallParameterNameError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -invalidLambdaParameterNameError :: Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core_.InvalidLambdaParameterNameError -invalidLambdaParameterNameError location name = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.InvalidLambdaParameterNameError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm location)}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm name)}]})) - -invalidLambdaParameterNameErrorLocation :: Phantoms.TTerm Core_.InvalidLambdaParameterNameError -> Phantoms.TTerm Paths.SubtermPath -invalidLambdaParameterNameErrorLocation x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidLambdaParameterNameError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -invalidLambdaParameterNameErrorName :: Phantoms.TTerm Core_.InvalidLambdaParameterNameError -> Phantoms.TTerm Core.Name -invalidLambdaParameterNameErrorName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidLambdaParameterNameError"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -invalidLambdaParameterNameErrorWithLocation :: Phantoms.TTerm Core_.InvalidLambdaParameterNameError -> Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core_.InvalidLambdaParameterNameError -invalidLambdaParameterNameErrorWithLocation original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.InvalidLambdaParameterNameError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidLambdaParameterNameError"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -invalidLambdaParameterNameErrorWithName :: Phantoms.TTerm Core_.InvalidLambdaParameterNameError -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core_.InvalidLambdaParameterNameError -invalidLambdaParameterNameErrorWithName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.InvalidLambdaParameterNameError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidLambdaParameterNameError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -invalidLetBindingNameError :: Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core_.InvalidLetBindingNameError -invalidLetBindingNameError location name = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.InvalidLetBindingNameError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm location)}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm name)}]})) - -invalidLetBindingNameErrorLocation :: Phantoms.TTerm Core_.InvalidLetBindingNameError -> Phantoms.TTerm Paths.SubtermPath -invalidLetBindingNameErrorLocation x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidLetBindingNameError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -invalidLetBindingNameErrorName :: Phantoms.TTerm Core_.InvalidLetBindingNameError -> Phantoms.TTerm Core.Name -invalidLetBindingNameErrorName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidLetBindingNameError"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -invalidLetBindingNameErrorWithLocation :: Phantoms.TTerm Core_.InvalidLetBindingNameError -> Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core_.InvalidLetBindingNameError -invalidLetBindingNameErrorWithLocation original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.InvalidLetBindingNameError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidLetBindingNameError"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -invalidLetBindingNameErrorWithName :: Phantoms.TTerm Core_.InvalidLetBindingNameError -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core_.InvalidLetBindingNameError -invalidLetBindingNameErrorWithName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.InvalidLetBindingNameError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidLetBindingNameError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -invalidTermErrorConstantCondition :: Phantoms.TTerm Core_.ConstantConditionError -> Phantoms.TTerm Core_.InvalidTermError -invalidTermErrorConstantCondition x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "constantCondition"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -invalidTermErrorDuplicateBinding :: Phantoms.TTerm Core_.DuplicateBindingError -> Phantoms.TTerm Core_.InvalidTermError -invalidTermErrorDuplicateBinding x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "duplicateBinding"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -invalidTermErrorDuplicateField :: Phantoms.TTerm Core_.DuplicateFieldError -> Phantoms.TTerm Core_.InvalidTermError -invalidTermErrorDuplicateField x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "duplicateField"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -invalidTermErrorEmptyCaseStatement :: Phantoms.TTerm Core_.EmptyCaseStatementError -> Phantoms.TTerm Core_.InvalidTermError -invalidTermErrorEmptyCaseStatement x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "emptyCaseStatement"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -invalidTermErrorEmptyLetBindings :: Phantoms.TTerm Core_.EmptyLetBindingsError -> Phantoms.TTerm Core_.InvalidTermError -invalidTermErrorEmptyLetBindings x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "emptyLetBindings"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -invalidTermErrorEmptyTermAnnotation :: Phantoms.TTerm Core_.EmptyTermAnnotationError -> Phantoms.TTerm Core_.InvalidTermError -invalidTermErrorEmptyTermAnnotation x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "emptyTermAnnotation"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -invalidTermErrorEmptyTypeNameInTerm :: Phantoms.TTerm Core_.EmptyTypeNameInTermError -> Phantoms.TTerm Core_.InvalidTermError -invalidTermErrorEmptyTypeNameInTerm x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "emptyTypeNameInTerm"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -invalidTermErrorInvalidLambdaParameterName :: Phantoms.TTerm Core_.InvalidLambdaParameterNameError -> Phantoms.TTerm Core_.InvalidTermError -invalidTermErrorInvalidLambdaParameterName x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "invalidLambdaParameterName"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -invalidTermErrorInvalidLetBindingName :: Phantoms.TTerm Core_.InvalidLetBindingNameError -> Phantoms.TTerm Core_.InvalidTermError -invalidTermErrorInvalidLetBindingName x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "invalidLetBindingName"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -invalidTermErrorInvalidTypeLambdaParameterName :: Phantoms.TTerm Core_.InvalidTypeLambdaParameterNameError -> Phantoms.TTerm Core_.InvalidTermError -invalidTermErrorInvalidTypeLambdaParameterName x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "invalidTypeLambdaParameterName"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -invalidTermErrorNestedTermAnnotation :: Phantoms.TTerm Core_.NestedTermAnnotationError -> Phantoms.TTerm Core_.InvalidTermError -invalidTermErrorNestedTermAnnotation x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "nestedTermAnnotation"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -invalidTermErrorRedundantWrapUnwrap :: Phantoms.TTerm Core_.RedundantWrapUnwrapError -> Phantoms.TTerm Core_.InvalidTermError -invalidTermErrorRedundantWrapUnwrap x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "redundantWrapUnwrap"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -invalidTermErrorSelfApplication :: Phantoms.TTerm Core_.SelfApplicationError -> Phantoms.TTerm Core_.InvalidTermError -invalidTermErrorSelfApplication x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "selfApplication"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -invalidTermErrorTermVariableShadowing :: Phantoms.TTerm Core_.TermVariableShadowingError -> Phantoms.TTerm Core_.InvalidTermError -invalidTermErrorTermVariableShadowing x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "termVariableShadowing"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -invalidTermErrorTypeVariableShadowingInTypeLambda :: Phantoms.TTerm Core_.TypeVariableShadowingInTypeLambdaError -> Phantoms.TTerm Core_.InvalidTermError -invalidTermErrorTypeVariableShadowingInTypeLambda x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "typeVariableShadowingInTypeLambda"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -invalidTermErrorUndefinedTermVariable :: Phantoms.TTerm Core_.UndefinedTermVariableError -> Phantoms.TTerm Core_.InvalidTermError -invalidTermErrorUndefinedTermVariable x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "undefinedTermVariable"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -invalidTermErrorUndefinedTypeVariableInBindingType :: Phantoms.TTerm Core_.UndefinedTypeVariableInBindingTypeError -> Phantoms.TTerm Core_.InvalidTermError -invalidTermErrorUndefinedTypeVariableInBindingType x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "undefinedTypeVariableInBindingType"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -invalidTermErrorUndefinedTypeVariableInLambdaDomain :: Phantoms.TTerm Core_.UndefinedTypeVariableInLambdaDomainError -> Phantoms.TTerm Core_.InvalidTermError -invalidTermErrorUndefinedTypeVariableInLambdaDomain x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "undefinedTypeVariableInLambdaDomain"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -invalidTermErrorUndefinedTypeVariableInTypeApplication :: Phantoms.TTerm Core_.UndefinedTypeVariableInTypeApplicationError -> Phantoms.TTerm Core_.InvalidTermError -invalidTermErrorUndefinedTypeVariableInTypeApplication x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "undefinedTypeVariableInTypeApplication"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -invalidTermErrorUnknownPrimitiveName :: Phantoms.TTerm Core_.UnknownPrimitiveNameError -> Phantoms.TTerm Core_.InvalidTermError -invalidTermErrorUnknownPrimitiveName x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unknownPrimitiveName"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -invalidTermErrorUnnecessaryIdentityApplication :: Phantoms.TTerm Core_.UnnecessaryIdentityApplicationError -> Phantoms.TTerm Core_.InvalidTermError -invalidTermErrorUnnecessaryIdentityApplication x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unnecessaryIdentityApplication"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -invalidTermErrorUntypedTermVariable :: Phantoms.TTerm Core_.UntypedTermVariableError -> Phantoms.TTerm Core_.InvalidTermError -invalidTermErrorUntypedTermVariable x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "untypedTermVariable"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -invalidTypeErrorDuplicateRecordTypeFieldNames :: Phantoms.TTerm Core_.DuplicateRecordTypeFieldNamesError -> Phantoms.TTerm Core_.InvalidTypeError -invalidTypeErrorDuplicateRecordTypeFieldNames x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "duplicateRecordTypeFieldNames"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -invalidTypeErrorDuplicateUnionTypeFieldNames :: Phantoms.TTerm Core_.DuplicateUnionTypeFieldNamesError -> Phantoms.TTerm Core_.InvalidTypeError -invalidTypeErrorDuplicateUnionTypeFieldNames x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "duplicateUnionTypeFieldNames"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -invalidTypeErrorEmptyRecordType :: Phantoms.TTerm Core_.EmptyRecordTypeError -> Phantoms.TTerm Core_.InvalidTypeError -invalidTypeErrorEmptyRecordType x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "emptyRecordType"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -invalidTypeErrorEmptyTypeAnnotation :: Phantoms.TTerm Core_.EmptyTypeAnnotationError -> Phantoms.TTerm Core_.InvalidTypeError -invalidTypeErrorEmptyTypeAnnotation x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "emptyTypeAnnotation"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -invalidTypeErrorEmptyUnionType :: Phantoms.TTerm Core_.EmptyUnionTypeError -> Phantoms.TTerm Core_.InvalidTypeError -invalidTypeErrorEmptyUnionType x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "emptyUnionType"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -invalidTypeErrorInvalidForallParameterName :: Phantoms.TTerm Core_.InvalidForallParameterNameError -> Phantoms.TTerm Core_.InvalidTypeError -invalidTypeErrorInvalidForallParameterName x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "invalidForallParameterName"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -invalidTypeErrorInvalidTypeSchemeVariableName :: Phantoms.TTerm Core_.InvalidTypeSchemeVariableNameError -> Phantoms.TTerm Core_.InvalidTypeError -invalidTypeErrorInvalidTypeSchemeVariableName x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "invalidTypeSchemeVariableName"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -invalidTypeErrorNestedTypeAnnotation :: Phantoms.TTerm Core_.NestedTypeAnnotationError -> Phantoms.TTerm Core_.InvalidTypeError -invalidTypeErrorNestedTypeAnnotation x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "nestedTypeAnnotation"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -invalidTypeErrorNonComparableMapKeyType :: Phantoms.TTerm Core_.NonComparableMapKeyTypeError -> Phantoms.TTerm Core_.InvalidTypeError -invalidTypeErrorNonComparableMapKeyType x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "nonComparableMapKeyType"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -invalidTypeErrorNonComparableSetElementType :: Phantoms.TTerm Core_.NonComparableSetElementTypeError -> Phantoms.TTerm Core_.InvalidTypeError -invalidTypeErrorNonComparableSetElementType x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "nonComparableSetElementType"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -invalidTypeErrorSingleVariantUnion :: Phantoms.TTerm Core_.SingleVariantUnionError -> Phantoms.TTerm Core_.InvalidTypeError -invalidTypeErrorSingleVariantUnion x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "singleVariantUnion"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -invalidTypeErrorTypeVariableShadowingInForall :: Phantoms.TTerm Core_.TypeVariableShadowingInForallError -> Phantoms.TTerm Core_.InvalidTypeError -invalidTypeErrorTypeVariableShadowingInForall x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "typeVariableShadowingInForall"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -invalidTypeErrorUndefinedTypeVariable :: Phantoms.TTerm Core_.UndefinedTypeVariableError -> Phantoms.TTerm Core_.InvalidTypeError -invalidTypeErrorUndefinedTypeVariable x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "undefinedTypeVariable"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -invalidTypeErrorVoidInNonBottomPosition :: Phantoms.TTerm Core_.VoidInNonBottomPositionError -> Phantoms.TTerm Core_.InvalidTypeError -invalidTypeErrorVoidInNonBottomPosition x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "voidInNonBottomPosition"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -invalidTypeLambdaParameterNameError :: Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core_.InvalidTypeLambdaParameterNameError -invalidTypeLambdaParameterNameError location name = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.InvalidTypeLambdaParameterNameError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm location)}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm name)}]})) - -invalidTypeLambdaParameterNameErrorLocation :: Phantoms.TTerm Core_.InvalidTypeLambdaParameterNameError -> Phantoms.TTerm Paths.SubtermPath -invalidTypeLambdaParameterNameErrorLocation x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidTypeLambdaParameterNameError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -invalidTypeLambdaParameterNameErrorName :: Phantoms.TTerm Core_.InvalidTypeLambdaParameterNameError -> Phantoms.TTerm Core.Name -invalidTypeLambdaParameterNameErrorName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidTypeLambdaParameterNameError"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -invalidTypeLambdaParameterNameErrorWithLocation :: Phantoms.TTerm Core_.InvalidTypeLambdaParameterNameError -> Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core_.InvalidTypeLambdaParameterNameError -invalidTypeLambdaParameterNameErrorWithLocation original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.InvalidTypeLambdaParameterNameError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidTypeLambdaParameterNameError"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -invalidTypeLambdaParameterNameErrorWithName :: Phantoms.TTerm Core_.InvalidTypeLambdaParameterNameError -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core_.InvalidTypeLambdaParameterNameError -invalidTypeLambdaParameterNameErrorWithName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.InvalidTypeLambdaParameterNameError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidTypeLambdaParameterNameError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -invalidTypeSchemeVariableNameError :: Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core_.InvalidTypeSchemeVariableNameError -invalidTypeSchemeVariableNameError location name = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.InvalidTypeSchemeVariableNameError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm location)}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm name)}]})) - -invalidTypeSchemeVariableNameErrorLocation :: Phantoms.TTerm Core_.InvalidTypeSchemeVariableNameError -> Phantoms.TTerm Paths.SubtermPath -invalidTypeSchemeVariableNameErrorLocation x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidTypeSchemeVariableNameError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -invalidTypeSchemeVariableNameErrorName :: Phantoms.TTerm Core_.InvalidTypeSchemeVariableNameError -> Phantoms.TTerm Core.Name -invalidTypeSchemeVariableNameErrorName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidTypeSchemeVariableNameError"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -invalidTypeSchemeVariableNameErrorWithLocation :: Phantoms.TTerm Core_.InvalidTypeSchemeVariableNameError -> Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core_.InvalidTypeSchemeVariableNameError -invalidTypeSchemeVariableNameErrorWithLocation original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.InvalidTypeSchemeVariableNameError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidTypeSchemeVariableNameError"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -invalidTypeSchemeVariableNameErrorWithName :: Phantoms.TTerm Core_.InvalidTypeSchemeVariableNameError -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core_.InvalidTypeSchemeVariableNameError -invalidTypeSchemeVariableNameErrorWithName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.InvalidTypeSchemeVariableNameError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidTypeSchemeVariableNameError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -nestedTermAnnotationError :: Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core_.NestedTermAnnotationError -nestedTermAnnotationError location = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.NestedTermAnnotationError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm location)}]})) - -nestedTermAnnotationErrorLocation :: Phantoms.TTerm Core_.NestedTermAnnotationError -> Phantoms.TTerm Paths.SubtermPath -nestedTermAnnotationErrorLocation x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.NestedTermAnnotationError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -nestedTermAnnotationErrorWithLocation :: Phantoms.TTerm Core_.NestedTermAnnotationError -> Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core_.NestedTermAnnotationError -nestedTermAnnotationErrorWithLocation original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.NestedTermAnnotationError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -nestedTypeAnnotationError :: Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core_.NestedTypeAnnotationError -nestedTypeAnnotationError location = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.NestedTypeAnnotationError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm location)}]})) - -nestedTypeAnnotationErrorLocation :: Phantoms.TTerm Core_.NestedTypeAnnotationError -> Phantoms.TTerm Paths.SubtermPath -nestedTypeAnnotationErrorLocation x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.NestedTypeAnnotationError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -nestedTypeAnnotationErrorWithLocation :: Phantoms.TTerm Core_.NestedTypeAnnotationError -> Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core_.NestedTypeAnnotationError -nestedTypeAnnotationErrorWithLocation original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.NestedTypeAnnotationError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -nonComparableMapKeyTypeError :: Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Core_.NonComparableMapKeyTypeError -nonComparableMapKeyTypeError location keyType = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.NonComparableMapKeyTypeError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm location)}, - Core.Field { - Core.fieldName = (Core.Name "keyType"), - Core.fieldTerm = (Phantoms.unTTerm keyType)}]})) - -nonComparableMapKeyTypeErrorKeyType :: Phantoms.TTerm Core_.NonComparableMapKeyTypeError -> Phantoms.TTerm Core.Type -nonComparableMapKeyTypeErrorKeyType x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.NonComparableMapKeyTypeError"), - Core.projectionField = (Core.Name "keyType")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -nonComparableMapKeyTypeErrorLocation :: Phantoms.TTerm Core_.NonComparableMapKeyTypeError -> Phantoms.TTerm Paths.SubtermPath -nonComparableMapKeyTypeErrorLocation x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.NonComparableMapKeyTypeError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -nonComparableMapKeyTypeErrorWithKeyType :: Phantoms.TTerm Core_.NonComparableMapKeyTypeError -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Core_.NonComparableMapKeyTypeError -nonComparableMapKeyTypeErrorWithKeyType original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.NonComparableMapKeyTypeError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.NonComparableMapKeyTypeError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "keyType"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -nonComparableMapKeyTypeErrorWithLocation :: Phantoms.TTerm Core_.NonComparableMapKeyTypeError -> Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core_.NonComparableMapKeyTypeError -nonComparableMapKeyTypeErrorWithLocation original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.NonComparableMapKeyTypeError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "keyType"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.NonComparableMapKeyTypeError"), - Core.projectionField = (Core.Name "keyType")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -nonComparableSetElementTypeError :: Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Core_.NonComparableSetElementTypeError -nonComparableSetElementTypeError location elementType = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.NonComparableSetElementTypeError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm location)}, - Core.Field { - Core.fieldName = (Core.Name "elementType"), - Core.fieldTerm = (Phantoms.unTTerm elementType)}]})) - -nonComparableSetElementTypeErrorElementType :: Phantoms.TTerm Core_.NonComparableSetElementTypeError -> Phantoms.TTerm Core.Type -nonComparableSetElementTypeErrorElementType x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.NonComparableSetElementTypeError"), - Core.projectionField = (Core.Name "elementType")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -nonComparableSetElementTypeErrorLocation :: Phantoms.TTerm Core_.NonComparableSetElementTypeError -> Phantoms.TTerm Paths.SubtermPath -nonComparableSetElementTypeErrorLocation x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.NonComparableSetElementTypeError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -nonComparableSetElementTypeErrorWithElementType :: Phantoms.TTerm Core_.NonComparableSetElementTypeError -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Core_.NonComparableSetElementTypeError -nonComparableSetElementTypeErrorWithElementType original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.NonComparableSetElementTypeError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.NonComparableSetElementTypeError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "elementType"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -nonComparableSetElementTypeErrorWithLocation :: Phantoms.TTerm Core_.NonComparableSetElementTypeError -> Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core_.NonComparableSetElementTypeError -nonComparableSetElementTypeErrorWithLocation original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.NonComparableSetElementTypeError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "elementType"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.NonComparableSetElementTypeError"), - Core.projectionField = (Core.Name "elementType")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -redundantWrapUnwrapError :: Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core_.RedundantWrapUnwrapError -redundantWrapUnwrapError location typeName = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.RedundantWrapUnwrapError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm location)}, - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Phantoms.unTTerm typeName)}]})) - -redundantWrapUnwrapErrorLocation :: Phantoms.TTerm Core_.RedundantWrapUnwrapError -> Phantoms.TTerm Paths.SubtermPath -redundantWrapUnwrapErrorLocation x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.RedundantWrapUnwrapError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -redundantWrapUnwrapErrorTypeName :: Phantoms.TTerm Core_.RedundantWrapUnwrapError -> Phantoms.TTerm Core.Name -redundantWrapUnwrapErrorTypeName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.RedundantWrapUnwrapError"), - Core.projectionField = (Core.Name "typeName")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -redundantWrapUnwrapErrorWithLocation :: Phantoms.TTerm Core_.RedundantWrapUnwrapError -> Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core_.RedundantWrapUnwrapError -redundantWrapUnwrapErrorWithLocation original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.RedundantWrapUnwrapError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.RedundantWrapUnwrapError"), - Core.projectionField = (Core.Name "typeName")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -redundantWrapUnwrapErrorWithTypeName :: Phantoms.TTerm Core_.RedundantWrapUnwrapError -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core_.RedundantWrapUnwrapError -redundantWrapUnwrapErrorWithTypeName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.RedundantWrapUnwrapError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.RedundantWrapUnwrapError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -selfApplicationError :: Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core_.SelfApplicationError -selfApplicationError location name = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.SelfApplicationError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm location)}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm name)}]})) - -selfApplicationErrorLocation :: Phantoms.TTerm Core_.SelfApplicationError -> Phantoms.TTerm Paths.SubtermPath -selfApplicationErrorLocation x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.SelfApplicationError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -selfApplicationErrorName :: Phantoms.TTerm Core_.SelfApplicationError -> Phantoms.TTerm Core.Name -selfApplicationErrorName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.SelfApplicationError"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -selfApplicationErrorWithLocation :: Phantoms.TTerm Core_.SelfApplicationError -> Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core_.SelfApplicationError -selfApplicationErrorWithLocation original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.SelfApplicationError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.SelfApplicationError"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -selfApplicationErrorWithName :: Phantoms.TTerm Core_.SelfApplicationError -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core_.SelfApplicationError -selfApplicationErrorWithName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.SelfApplicationError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.SelfApplicationError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -singleVariantUnionError :: Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core_.SingleVariantUnionError -singleVariantUnionError location fieldName = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.SingleVariantUnionError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm location)}, - Core.Field { - Core.fieldName = (Core.Name "fieldName"), - Core.fieldTerm = (Phantoms.unTTerm fieldName)}]})) - -singleVariantUnionErrorFieldName :: Phantoms.TTerm Core_.SingleVariantUnionError -> Phantoms.TTerm Core.Name -singleVariantUnionErrorFieldName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.SingleVariantUnionError"), - Core.projectionField = (Core.Name "fieldName")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -singleVariantUnionErrorLocation :: Phantoms.TTerm Core_.SingleVariantUnionError -> Phantoms.TTerm Paths.SubtermPath -singleVariantUnionErrorLocation x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.SingleVariantUnionError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -singleVariantUnionErrorWithFieldName :: Phantoms.TTerm Core_.SingleVariantUnionError -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core_.SingleVariantUnionError -singleVariantUnionErrorWithFieldName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.SingleVariantUnionError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.SingleVariantUnionError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "fieldName"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -singleVariantUnionErrorWithLocation :: Phantoms.TTerm Core_.SingleVariantUnionError -> Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core_.SingleVariantUnionError -singleVariantUnionErrorWithLocation original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.SingleVariantUnionError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "fieldName"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.SingleVariantUnionError"), - Core.projectionField = (Core.Name "fieldName")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -termVariableShadowingError :: Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core_.TermVariableShadowingError -termVariableShadowingError location name = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.TermVariableShadowingError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm location)}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm name)}]})) - -termVariableShadowingErrorLocation :: Phantoms.TTerm Core_.TermVariableShadowingError -> Phantoms.TTerm Paths.SubtermPath -termVariableShadowingErrorLocation x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.TermVariableShadowingError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -termVariableShadowingErrorName :: Phantoms.TTerm Core_.TermVariableShadowingError -> Phantoms.TTerm Core.Name -termVariableShadowingErrorName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.TermVariableShadowingError"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -termVariableShadowingErrorWithLocation :: Phantoms.TTerm Core_.TermVariableShadowingError -> Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core_.TermVariableShadowingError -termVariableShadowingErrorWithLocation original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.TermVariableShadowingError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.TermVariableShadowingError"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -termVariableShadowingErrorWithName :: Phantoms.TTerm Core_.TermVariableShadowingError -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core_.TermVariableShadowingError -termVariableShadowingErrorWithName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.TermVariableShadowingError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.TermVariableShadowingError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -typeVariableShadowingInForallError :: Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core_.TypeVariableShadowingInForallError -typeVariableShadowingInForallError location name = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.TypeVariableShadowingInForallError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm location)}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm name)}]})) - -typeVariableShadowingInForallErrorLocation :: Phantoms.TTerm Core_.TypeVariableShadowingInForallError -> Phantoms.TTerm Paths.SubtermPath -typeVariableShadowingInForallErrorLocation x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.TypeVariableShadowingInForallError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -typeVariableShadowingInForallErrorName :: Phantoms.TTerm Core_.TypeVariableShadowingInForallError -> Phantoms.TTerm Core.Name -typeVariableShadowingInForallErrorName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.TypeVariableShadowingInForallError"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -typeVariableShadowingInForallErrorWithLocation :: Phantoms.TTerm Core_.TypeVariableShadowingInForallError -> Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core_.TypeVariableShadowingInForallError -typeVariableShadowingInForallErrorWithLocation original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.TypeVariableShadowingInForallError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.TypeVariableShadowingInForallError"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -typeVariableShadowingInForallErrorWithName :: Phantoms.TTerm Core_.TypeVariableShadowingInForallError -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core_.TypeVariableShadowingInForallError -typeVariableShadowingInForallErrorWithName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.TypeVariableShadowingInForallError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.TypeVariableShadowingInForallError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -typeVariableShadowingInTypeLambdaError :: Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core_.TypeVariableShadowingInTypeLambdaError -typeVariableShadowingInTypeLambdaError location name = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.TypeVariableShadowingInTypeLambdaError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm location)}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm name)}]})) - -typeVariableShadowingInTypeLambdaErrorLocation :: Phantoms.TTerm Core_.TypeVariableShadowingInTypeLambdaError -> Phantoms.TTerm Paths.SubtermPath -typeVariableShadowingInTypeLambdaErrorLocation x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.TypeVariableShadowingInTypeLambdaError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -typeVariableShadowingInTypeLambdaErrorName :: Phantoms.TTerm Core_.TypeVariableShadowingInTypeLambdaError -> Phantoms.TTerm Core.Name -typeVariableShadowingInTypeLambdaErrorName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.TypeVariableShadowingInTypeLambdaError"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -typeVariableShadowingInTypeLambdaErrorWithLocation :: Phantoms.TTerm Core_.TypeVariableShadowingInTypeLambdaError -> Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core_.TypeVariableShadowingInTypeLambdaError -typeVariableShadowingInTypeLambdaErrorWithLocation original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.TypeVariableShadowingInTypeLambdaError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.TypeVariableShadowingInTypeLambdaError"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -typeVariableShadowingInTypeLambdaErrorWithName :: Phantoms.TTerm Core_.TypeVariableShadowingInTypeLambdaError -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core_.TypeVariableShadowingInTypeLambdaError -typeVariableShadowingInTypeLambdaErrorWithName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.TypeVariableShadowingInTypeLambdaError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.TypeVariableShadowingInTypeLambdaError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -undefinedFieldError :: Phantoms.TTerm Core.Name -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core_.UndefinedFieldError -undefinedFieldError fieldName typeName = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedFieldError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "fieldName"), - Core.fieldTerm = (Phantoms.unTTerm fieldName)}, - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Phantoms.unTTerm typeName)}]})) - -undefinedFieldErrorFieldName :: Phantoms.TTerm Core_.UndefinedFieldError -> Phantoms.TTerm Core.Name -undefinedFieldErrorFieldName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedFieldError"), - Core.projectionField = (Core.Name "fieldName")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -undefinedFieldErrorTypeName :: Phantoms.TTerm Core_.UndefinedFieldError -> Phantoms.TTerm Core.Name -undefinedFieldErrorTypeName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedFieldError"), - Core.projectionField = (Core.Name "typeName")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -undefinedFieldErrorWithFieldName :: Phantoms.TTerm Core_.UndefinedFieldError -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core_.UndefinedFieldError -undefinedFieldErrorWithFieldName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedFieldError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "fieldName"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedFieldError"), - Core.projectionField = (Core.Name "typeName")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -undefinedFieldErrorWithTypeName :: Phantoms.TTerm Core_.UndefinedFieldError -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core_.UndefinedFieldError -undefinedFieldErrorWithTypeName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedFieldError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "fieldName"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedFieldError"), - Core.projectionField = (Core.Name "fieldName")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -undefinedTermVariableError :: Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core_.UndefinedTermVariableError -undefinedTermVariableError location name = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedTermVariableError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm location)}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm name)}]})) - -undefinedTermVariableErrorLocation :: Phantoms.TTerm Core_.UndefinedTermVariableError -> Phantoms.TTerm Paths.SubtermPath -undefinedTermVariableErrorLocation x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTermVariableError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -undefinedTermVariableErrorName :: Phantoms.TTerm Core_.UndefinedTermVariableError -> Phantoms.TTerm Core.Name -undefinedTermVariableErrorName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTermVariableError"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -undefinedTermVariableErrorWithLocation :: Phantoms.TTerm Core_.UndefinedTermVariableError -> Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core_.UndefinedTermVariableError -undefinedTermVariableErrorWithLocation original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedTermVariableError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTermVariableError"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -undefinedTermVariableErrorWithName :: Phantoms.TTerm Core_.UndefinedTermVariableError -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core_.UndefinedTermVariableError -undefinedTermVariableErrorWithName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedTermVariableError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTermVariableError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -undefinedTypeVariableError :: Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core_.UndefinedTypeVariableError -undefinedTypeVariableError location name = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm location)}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm name)}]})) - -undefinedTypeVariableErrorLocation :: Phantoms.TTerm Core_.UndefinedTypeVariableError -> Phantoms.TTerm Paths.SubtermPath -undefinedTypeVariableErrorLocation x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -undefinedTypeVariableErrorName :: Phantoms.TTerm Core_.UndefinedTypeVariableError -> Phantoms.TTerm Core.Name -undefinedTypeVariableErrorName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableError"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -undefinedTypeVariableErrorWithLocation :: Phantoms.TTerm Core_.UndefinedTypeVariableError -> Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core_.UndefinedTypeVariableError -undefinedTypeVariableErrorWithLocation original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableError"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -undefinedTypeVariableErrorWithName :: Phantoms.TTerm Core_.UndefinedTypeVariableError -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core_.UndefinedTypeVariableError -undefinedTypeVariableErrorWithName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -undefinedTypeVariableInBindingTypeError :: Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core_.UndefinedTypeVariableInBindingTypeError -undefinedTypeVariableInBindingTypeError location name = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInBindingTypeError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm location)}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm name)}]})) - -undefinedTypeVariableInBindingTypeErrorLocation :: Phantoms.TTerm Core_.UndefinedTypeVariableInBindingTypeError -> Phantoms.TTerm Paths.SubtermPath -undefinedTypeVariableInBindingTypeErrorLocation x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInBindingTypeError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -undefinedTypeVariableInBindingTypeErrorName :: Phantoms.TTerm Core_.UndefinedTypeVariableInBindingTypeError -> Phantoms.TTerm Core.Name -undefinedTypeVariableInBindingTypeErrorName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInBindingTypeError"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -undefinedTypeVariableInBindingTypeErrorWithLocation :: Phantoms.TTerm Core_.UndefinedTypeVariableInBindingTypeError -> Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core_.UndefinedTypeVariableInBindingTypeError -undefinedTypeVariableInBindingTypeErrorWithLocation original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInBindingTypeError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInBindingTypeError"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -undefinedTypeVariableInBindingTypeErrorWithName :: Phantoms.TTerm Core_.UndefinedTypeVariableInBindingTypeError -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core_.UndefinedTypeVariableInBindingTypeError -undefinedTypeVariableInBindingTypeErrorWithName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInBindingTypeError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInBindingTypeError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -undefinedTypeVariableInLambdaDomainError :: Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core_.UndefinedTypeVariableInLambdaDomainError -undefinedTypeVariableInLambdaDomainError location name = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInLambdaDomainError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm location)}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm name)}]})) - -undefinedTypeVariableInLambdaDomainErrorLocation :: Phantoms.TTerm Core_.UndefinedTypeVariableInLambdaDomainError -> Phantoms.TTerm Paths.SubtermPath -undefinedTypeVariableInLambdaDomainErrorLocation x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInLambdaDomainError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -undefinedTypeVariableInLambdaDomainErrorName :: Phantoms.TTerm Core_.UndefinedTypeVariableInLambdaDomainError -> Phantoms.TTerm Core.Name -undefinedTypeVariableInLambdaDomainErrorName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInLambdaDomainError"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -undefinedTypeVariableInLambdaDomainErrorWithLocation :: Phantoms.TTerm Core_.UndefinedTypeVariableInLambdaDomainError -> Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core_.UndefinedTypeVariableInLambdaDomainError -undefinedTypeVariableInLambdaDomainErrorWithLocation original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInLambdaDomainError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInLambdaDomainError"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -undefinedTypeVariableInLambdaDomainErrorWithName :: Phantoms.TTerm Core_.UndefinedTypeVariableInLambdaDomainError -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core_.UndefinedTypeVariableInLambdaDomainError -undefinedTypeVariableInLambdaDomainErrorWithName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInLambdaDomainError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInLambdaDomainError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -undefinedTypeVariableInTypeApplicationError :: Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core_.UndefinedTypeVariableInTypeApplicationError -undefinedTypeVariableInTypeApplicationError location name = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInTypeApplicationError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm location)}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm name)}]})) - -undefinedTypeVariableInTypeApplicationErrorLocation :: Phantoms.TTerm Core_.UndefinedTypeVariableInTypeApplicationError -> Phantoms.TTerm Paths.SubtermPath -undefinedTypeVariableInTypeApplicationErrorLocation x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInTypeApplicationError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -undefinedTypeVariableInTypeApplicationErrorName :: Phantoms.TTerm Core_.UndefinedTypeVariableInTypeApplicationError -> Phantoms.TTerm Core.Name -undefinedTypeVariableInTypeApplicationErrorName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInTypeApplicationError"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -undefinedTypeVariableInTypeApplicationErrorWithLocation :: Phantoms.TTerm Core_.UndefinedTypeVariableInTypeApplicationError -> Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core_.UndefinedTypeVariableInTypeApplicationError -undefinedTypeVariableInTypeApplicationErrorWithLocation original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInTypeApplicationError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInTypeApplicationError"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -undefinedTypeVariableInTypeApplicationErrorWithName :: Phantoms.TTerm Core_.UndefinedTypeVariableInTypeApplicationError -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core_.UndefinedTypeVariableInTypeApplicationError -undefinedTypeVariableInTypeApplicationErrorWithName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInTypeApplicationError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInTypeApplicationError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -unexpectedTermVariantError :: Phantoms.TTerm Variants.TermVariant -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Core_.UnexpectedTermVariantError -unexpectedTermVariantError expectedVariant actualTerm = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UnexpectedTermVariantError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "expectedVariant"), - Core.fieldTerm = (Phantoms.unTTerm expectedVariant)}, - Core.Field { - Core.fieldName = (Core.Name "actualTerm"), - Core.fieldTerm = (Phantoms.unTTerm actualTerm)}]})) - -unexpectedTermVariantErrorActualTerm :: Phantoms.TTerm Core_.UnexpectedTermVariantError -> Phantoms.TTerm Core.Term -unexpectedTermVariantErrorActualTerm x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UnexpectedTermVariantError"), - Core.projectionField = (Core.Name "actualTerm")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -unexpectedTermVariantErrorExpectedVariant :: Phantoms.TTerm Core_.UnexpectedTermVariantError -> Phantoms.TTerm Variants.TermVariant -unexpectedTermVariantErrorExpectedVariant x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UnexpectedTermVariantError"), - Core.projectionField = (Core.Name "expectedVariant")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -unexpectedTermVariantErrorWithActualTerm :: Phantoms.TTerm Core_.UnexpectedTermVariantError -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Core_.UnexpectedTermVariantError -unexpectedTermVariantErrorWithActualTerm original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UnexpectedTermVariantError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "expectedVariant"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UnexpectedTermVariantError"), - Core.projectionField = (Core.Name "expectedVariant")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "actualTerm"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -unexpectedTermVariantErrorWithExpectedVariant :: Phantoms.TTerm Core_.UnexpectedTermVariantError -> Phantoms.TTerm Variants.TermVariant -> Phantoms.TTerm Core_.UnexpectedTermVariantError -unexpectedTermVariantErrorWithExpectedVariant original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UnexpectedTermVariantError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "expectedVariant"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "actualTerm"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UnexpectedTermVariantError"), - Core.projectionField = (Core.Name "actualTerm")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -unexpectedTypeVariantError :: Phantoms.TTerm Variants.TypeVariant -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Core_.UnexpectedTypeVariantError -unexpectedTypeVariantError expectedVariant actualType = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UnexpectedTypeVariantError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "expectedVariant"), - Core.fieldTerm = (Phantoms.unTTerm expectedVariant)}, - Core.Field { - Core.fieldName = (Core.Name "actualType"), - Core.fieldTerm = (Phantoms.unTTerm actualType)}]})) - -unexpectedTypeVariantErrorActualType :: Phantoms.TTerm Core_.UnexpectedTypeVariantError -> Phantoms.TTerm Core.Type -unexpectedTypeVariantErrorActualType x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UnexpectedTypeVariantError"), - Core.projectionField = (Core.Name "actualType")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -unexpectedTypeVariantErrorExpectedVariant :: Phantoms.TTerm Core_.UnexpectedTypeVariantError -> Phantoms.TTerm Variants.TypeVariant -unexpectedTypeVariantErrorExpectedVariant x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UnexpectedTypeVariantError"), - Core.projectionField = (Core.Name "expectedVariant")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -unexpectedTypeVariantErrorWithActualType :: Phantoms.TTerm Core_.UnexpectedTypeVariantError -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Core_.UnexpectedTypeVariantError -unexpectedTypeVariantErrorWithActualType original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UnexpectedTypeVariantError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "expectedVariant"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UnexpectedTypeVariantError"), - Core.projectionField = (Core.Name "expectedVariant")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "actualType"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -unexpectedTypeVariantErrorWithExpectedVariant :: Phantoms.TTerm Core_.UnexpectedTypeVariantError -> Phantoms.TTerm Variants.TypeVariant -> Phantoms.TTerm Core_.UnexpectedTypeVariantError -unexpectedTypeVariantErrorWithExpectedVariant original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UnexpectedTypeVariantError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "expectedVariant"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "actualType"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UnexpectedTypeVariantError"), - Core.projectionField = (Core.Name "actualType")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -unknownPrimitiveNameError :: Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core_.UnknownPrimitiveNameError -unknownPrimitiveNameError location name = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UnknownPrimitiveNameError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm location)}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm name)}]})) - -unknownPrimitiveNameErrorLocation :: Phantoms.TTerm Core_.UnknownPrimitiveNameError -> Phantoms.TTerm Paths.SubtermPath -unknownPrimitiveNameErrorLocation x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UnknownPrimitiveNameError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -unknownPrimitiveNameErrorName :: Phantoms.TTerm Core_.UnknownPrimitiveNameError -> Phantoms.TTerm Core.Name -unknownPrimitiveNameErrorName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UnknownPrimitiveNameError"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -unknownPrimitiveNameErrorWithLocation :: Phantoms.TTerm Core_.UnknownPrimitiveNameError -> Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core_.UnknownPrimitiveNameError -unknownPrimitiveNameErrorWithLocation original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UnknownPrimitiveNameError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UnknownPrimitiveNameError"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -unknownPrimitiveNameErrorWithName :: Phantoms.TTerm Core_.UnknownPrimitiveNameError -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core_.UnknownPrimitiveNameError -unknownPrimitiveNameErrorWithName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UnknownPrimitiveNameError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UnknownPrimitiveNameError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -unnecessaryIdentityApplicationError :: Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core_.UnnecessaryIdentityApplicationError -unnecessaryIdentityApplicationError location = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UnnecessaryIdentityApplicationError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm location)}]})) - -unnecessaryIdentityApplicationErrorLocation :: Phantoms.TTerm Core_.UnnecessaryIdentityApplicationError -> Phantoms.TTerm Paths.SubtermPath -unnecessaryIdentityApplicationErrorLocation x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UnnecessaryIdentityApplicationError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -unnecessaryIdentityApplicationErrorWithLocation :: Phantoms.TTerm Core_.UnnecessaryIdentityApplicationError -> Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core_.UnnecessaryIdentityApplicationError -unnecessaryIdentityApplicationErrorWithLocation original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UnnecessaryIdentityApplicationError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -untypedTermVariableError :: Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core_.UntypedTermVariableError -untypedTermVariableError location name = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UntypedTermVariableError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm location)}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm name)}]})) - -untypedTermVariableErrorLocation :: Phantoms.TTerm Core_.UntypedTermVariableError -> Phantoms.TTerm Paths.SubtermPath -untypedTermVariableErrorLocation x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UntypedTermVariableError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -untypedTermVariableErrorName :: Phantoms.TTerm Core_.UntypedTermVariableError -> Phantoms.TTerm Core.Name -untypedTermVariableErrorName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UntypedTermVariableError"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -untypedTermVariableErrorWithLocation :: Phantoms.TTerm Core_.UntypedTermVariableError -> Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core_.UntypedTermVariableError -untypedTermVariableErrorWithLocation original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UntypedTermVariableError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UntypedTermVariableError"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -untypedTermVariableErrorWithName :: Phantoms.TTerm Core_.UntypedTermVariableError -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core_.UntypedTermVariableError -untypedTermVariableErrorWithName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UntypedTermVariableError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.UntypedTermVariableError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -voidInNonBottomPositionError :: Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core_.VoidInNonBottomPositionError -voidInNonBottomPositionError location = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.VoidInNonBottomPositionError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm location)}]})) - -voidInNonBottomPositionErrorLocation :: Phantoms.TTerm Core_.VoidInNonBottomPositionError -> Phantoms.TTerm Paths.SubtermPath -voidInNonBottomPositionErrorLocation x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.core.VoidInNonBottomPositionError"), - Core.projectionField = (Core.Name "location")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -voidInNonBottomPositionErrorWithLocation :: Phantoms.TTerm Core_.VoidInNonBottomPositionError -> Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Core_.VoidInNonBottomPositionError -voidInNonBottomPositionErrorWithLocation original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.VoidInNonBottomPositionError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) diff --git a/src/gen-main/haskell/Hydra/Dsl/Error/Packaging.hs b/src/gen-main/haskell/Hydra/Dsl/Error/Packaging.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Dsl/Error/Packaging.hs +++ /dev/null @@ -1,440 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | DSL functions for hydra.error.packaging - -module Hydra.Dsl.Error.Packaging where - -import qualified Hydra.Core as Core -import qualified Hydra.Error.Packaging as Packaging -import qualified Hydra.Module as Module -import qualified Hydra.Phantoms as Phantoms -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -conflictingModuleNamespaceError :: Phantoms.TTerm Module.Namespace -> Phantoms.TTerm Module.Namespace -> Phantoms.TTerm Packaging.ConflictingModuleNamespaceError -conflictingModuleNamespaceError first second = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.packaging.ConflictingModuleNamespaceError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "first"), - Core.fieldTerm = (Phantoms.unTTerm first)}, - Core.Field { - Core.fieldName = (Core.Name "second"), - Core.fieldTerm = (Phantoms.unTTerm second)}]})) - -conflictingModuleNamespaceErrorFirst :: Phantoms.TTerm Packaging.ConflictingModuleNamespaceError -> Phantoms.TTerm Module.Namespace -conflictingModuleNamespaceErrorFirst x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.packaging.ConflictingModuleNamespaceError"), - Core.projectionField = (Core.Name "first")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -conflictingModuleNamespaceErrorSecond :: Phantoms.TTerm Packaging.ConflictingModuleNamespaceError -> Phantoms.TTerm Module.Namespace -conflictingModuleNamespaceErrorSecond x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.packaging.ConflictingModuleNamespaceError"), - Core.projectionField = (Core.Name "second")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -conflictingModuleNamespaceErrorWithFirst :: Phantoms.TTerm Packaging.ConflictingModuleNamespaceError -> Phantoms.TTerm Module.Namespace -> Phantoms.TTerm Packaging.ConflictingModuleNamespaceError -conflictingModuleNamespaceErrorWithFirst original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.packaging.ConflictingModuleNamespaceError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "first"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "second"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.packaging.ConflictingModuleNamespaceError"), - Core.projectionField = (Core.Name "second")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -conflictingModuleNamespaceErrorWithSecond :: Phantoms.TTerm Packaging.ConflictingModuleNamespaceError -> Phantoms.TTerm Module.Namespace -> Phantoms.TTerm Packaging.ConflictingModuleNamespaceError -conflictingModuleNamespaceErrorWithSecond original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.packaging.ConflictingModuleNamespaceError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "first"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.packaging.ConflictingModuleNamespaceError"), - Core.projectionField = (Core.Name "first")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "second"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -conflictingVariantNameError :: Phantoms.TTerm Module.Namespace -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Packaging.ConflictingVariantNameError -conflictingVariantNameError namespace typeName variantName conflictingName = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.packaging.ConflictingVariantNameError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "namespace"), - Core.fieldTerm = (Phantoms.unTTerm namespace)}, - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Phantoms.unTTerm typeName)}, - Core.Field { - Core.fieldName = (Core.Name "variantName"), - Core.fieldTerm = (Phantoms.unTTerm variantName)}, - Core.Field { - Core.fieldName = (Core.Name "conflictingName"), - Core.fieldTerm = (Phantoms.unTTerm conflictingName)}]})) - -conflictingVariantNameErrorConflictingName :: Phantoms.TTerm Packaging.ConflictingVariantNameError -> Phantoms.TTerm Core.Name -conflictingVariantNameErrorConflictingName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.packaging.ConflictingVariantNameError"), - Core.projectionField = (Core.Name "conflictingName")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -conflictingVariantNameErrorNamespace :: Phantoms.TTerm Packaging.ConflictingVariantNameError -> Phantoms.TTerm Module.Namespace -conflictingVariantNameErrorNamespace x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.packaging.ConflictingVariantNameError"), - Core.projectionField = (Core.Name "namespace")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -conflictingVariantNameErrorTypeName :: Phantoms.TTerm Packaging.ConflictingVariantNameError -> Phantoms.TTerm Core.Name -conflictingVariantNameErrorTypeName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.packaging.ConflictingVariantNameError"), - Core.projectionField = (Core.Name "typeName")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -conflictingVariantNameErrorVariantName :: Phantoms.TTerm Packaging.ConflictingVariantNameError -> Phantoms.TTerm Core.Name -conflictingVariantNameErrorVariantName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.packaging.ConflictingVariantNameError"), - Core.projectionField = (Core.Name "variantName")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -conflictingVariantNameErrorWithConflictingName :: Phantoms.TTerm Packaging.ConflictingVariantNameError -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Packaging.ConflictingVariantNameError -conflictingVariantNameErrorWithConflictingName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.packaging.ConflictingVariantNameError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "namespace"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.packaging.ConflictingVariantNameError"), - Core.projectionField = (Core.Name "namespace")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.packaging.ConflictingVariantNameError"), - Core.projectionField = (Core.Name "typeName")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "variantName"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.packaging.ConflictingVariantNameError"), - Core.projectionField = (Core.Name "variantName")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "conflictingName"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -conflictingVariantNameErrorWithNamespace :: Phantoms.TTerm Packaging.ConflictingVariantNameError -> Phantoms.TTerm Module.Namespace -> Phantoms.TTerm Packaging.ConflictingVariantNameError -conflictingVariantNameErrorWithNamespace original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.packaging.ConflictingVariantNameError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "namespace"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.packaging.ConflictingVariantNameError"), - Core.projectionField = (Core.Name "typeName")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "variantName"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.packaging.ConflictingVariantNameError"), - Core.projectionField = (Core.Name "variantName")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "conflictingName"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.packaging.ConflictingVariantNameError"), - Core.projectionField = (Core.Name "conflictingName")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -conflictingVariantNameErrorWithTypeName :: Phantoms.TTerm Packaging.ConflictingVariantNameError -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Packaging.ConflictingVariantNameError -conflictingVariantNameErrorWithTypeName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.packaging.ConflictingVariantNameError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "namespace"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.packaging.ConflictingVariantNameError"), - Core.projectionField = (Core.Name "namespace")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "variantName"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.packaging.ConflictingVariantNameError"), - Core.projectionField = (Core.Name "variantName")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "conflictingName"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.packaging.ConflictingVariantNameError"), - Core.projectionField = (Core.Name "conflictingName")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -conflictingVariantNameErrorWithVariantName :: Phantoms.TTerm Packaging.ConflictingVariantNameError -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Packaging.ConflictingVariantNameError -conflictingVariantNameErrorWithVariantName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.packaging.ConflictingVariantNameError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "namespace"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.packaging.ConflictingVariantNameError"), - Core.projectionField = (Core.Name "namespace")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.packaging.ConflictingVariantNameError"), - Core.projectionField = (Core.Name "typeName")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "variantName"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "conflictingName"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.packaging.ConflictingVariantNameError"), - Core.projectionField = (Core.Name "conflictingName")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -definitionNotInModuleNamespaceError :: Phantoms.TTerm Module.Namespace -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Packaging.DefinitionNotInModuleNamespaceError -definitionNotInModuleNamespaceError namespace name = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.packaging.DefinitionNotInModuleNamespaceError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "namespace"), - Core.fieldTerm = (Phantoms.unTTerm namespace)}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm name)}]})) - -definitionNotInModuleNamespaceErrorName :: Phantoms.TTerm Packaging.DefinitionNotInModuleNamespaceError -> Phantoms.TTerm Core.Name -definitionNotInModuleNamespaceErrorName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.packaging.DefinitionNotInModuleNamespaceError"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -definitionNotInModuleNamespaceErrorNamespace :: Phantoms.TTerm Packaging.DefinitionNotInModuleNamespaceError -> Phantoms.TTerm Module.Namespace -definitionNotInModuleNamespaceErrorNamespace x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.packaging.DefinitionNotInModuleNamespaceError"), - Core.projectionField = (Core.Name "namespace")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -definitionNotInModuleNamespaceErrorWithName :: Phantoms.TTerm Packaging.DefinitionNotInModuleNamespaceError -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Packaging.DefinitionNotInModuleNamespaceError -definitionNotInModuleNamespaceErrorWithName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.packaging.DefinitionNotInModuleNamespaceError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "namespace"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.packaging.DefinitionNotInModuleNamespaceError"), - Core.projectionField = (Core.Name "namespace")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -definitionNotInModuleNamespaceErrorWithNamespace :: Phantoms.TTerm Packaging.DefinitionNotInModuleNamespaceError -> Phantoms.TTerm Module.Namespace -> Phantoms.TTerm Packaging.DefinitionNotInModuleNamespaceError -definitionNotInModuleNamespaceErrorWithNamespace original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.packaging.DefinitionNotInModuleNamespaceError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "namespace"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.packaging.DefinitionNotInModuleNamespaceError"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -duplicateDefinitionNameError :: Phantoms.TTerm Module.Namespace -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Packaging.DuplicateDefinitionNameError -duplicateDefinitionNameError namespace name = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.packaging.DuplicateDefinitionNameError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "namespace"), - Core.fieldTerm = (Phantoms.unTTerm namespace)}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm name)}]})) - -duplicateDefinitionNameErrorName :: Phantoms.TTerm Packaging.DuplicateDefinitionNameError -> Phantoms.TTerm Core.Name -duplicateDefinitionNameErrorName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.packaging.DuplicateDefinitionNameError"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -duplicateDefinitionNameErrorNamespace :: Phantoms.TTerm Packaging.DuplicateDefinitionNameError -> Phantoms.TTerm Module.Namespace -duplicateDefinitionNameErrorNamespace x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.packaging.DuplicateDefinitionNameError"), - Core.projectionField = (Core.Name "namespace")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -duplicateDefinitionNameErrorWithName :: Phantoms.TTerm Packaging.DuplicateDefinitionNameError -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Packaging.DuplicateDefinitionNameError -duplicateDefinitionNameErrorWithName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.packaging.DuplicateDefinitionNameError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "namespace"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.packaging.DuplicateDefinitionNameError"), - Core.projectionField = (Core.Name "namespace")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -duplicateDefinitionNameErrorWithNamespace :: Phantoms.TTerm Packaging.DuplicateDefinitionNameError -> Phantoms.TTerm Module.Namespace -> Phantoms.TTerm Packaging.DuplicateDefinitionNameError -duplicateDefinitionNameErrorWithNamespace original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.packaging.DuplicateDefinitionNameError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "namespace"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.packaging.DuplicateDefinitionNameError"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -duplicateModuleNamespaceError :: Phantoms.TTerm Module.Namespace -> Phantoms.TTerm Packaging.DuplicateModuleNamespaceError -duplicateModuleNamespaceError namespace = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.packaging.DuplicateModuleNamespaceError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "namespace"), - Core.fieldTerm = (Phantoms.unTTerm namespace)}]})) - -duplicateModuleNamespaceErrorNamespace :: Phantoms.TTerm Packaging.DuplicateModuleNamespaceError -> Phantoms.TTerm Module.Namespace -duplicateModuleNamespaceErrorNamespace x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.error.packaging.DuplicateModuleNamespaceError"), - Core.projectionField = (Core.Name "namespace")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -duplicateModuleNamespaceErrorWithNamespace :: Phantoms.TTerm Packaging.DuplicateModuleNamespaceError -> Phantoms.TTerm Module.Namespace -> Phantoms.TTerm Packaging.DuplicateModuleNamespaceError -duplicateModuleNamespaceErrorWithNamespace original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.packaging.DuplicateModuleNamespaceError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "namespace"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -invalidModuleErrorConflictingVariantName :: Phantoms.TTerm Packaging.ConflictingVariantNameError -> Phantoms.TTerm Packaging.InvalidModuleError -invalidModuleErrorConflictingVariantName x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidModuleError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "conflictingVariantName"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -invalidModuleErrorDefinitionNotInModuleNamespace :: Phantoms.TTerm Packaging.DefinitionNotInModuleNamespaceError -> Phantoms.TTerm Packaging.InvalidModuleError -invalidModuleErrorDefinitionNotInModuleNamespace x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidModuleError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "definitionNotInModuleNamespace"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -invalidModuleErrorDuplicateDefinitionName :: Phantoms.TTerm Packaging.DuplicateDefinitionNameError -> Phantoms.TTerm Packaging.InvalidModuleError -invalidModuleErrorDuplicateDefinitionName x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidModuleError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "duplicateDefinitionName"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -invalidPackageErrorConflictingModuleNamespace :: Phantoms.TTerm Packaging.ConflictingModuleNamespaceError -> Phantoms.TTerm Packaging.InvalidPackageError -invalidPackageErrorConflictingModuleNamespace x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidPackageError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "conflictingModuleNamespace"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -invalidPackageErrorDuplicateModuleNamespace :: Phantoms.TTerm Packaging.DuplicateModuleNamespaceError -> Phantoms.TTerm Packaging.InvalidPackageError -invalidPackageErrorDuplicateModuleNamespace x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidPackageError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "duplicateModuleNamespace"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -invalidPackageErrorInvalidModule :: Phantoms.TTerm Packaging.InvalidModuleError -> Phantoms.TTerm Packaging.InvalidPackageError -invalidPackageErrorInvalidModule x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidPackageError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "invalidModule"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) diff --git a/src/gen-main/haskell/Hydra/Dsl/Errors.hs b/src/gen-main/haskell/Hydra/Dsl/Errors.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Dsl/Errors.hs +++ /dev/null @@ -1,237 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | DSL functions for hydra.errors - -module Hydra.Dsl.Errors where - -import qualified Hydra.Core as Core -import qualified Hydra.Error.Checking as Checking -import qualified Hydra.Error.Core as Core_ -import qualified Hydra.Errors as Errors -import qualified Hydra.Phantoms as Phantoms -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -decodingError :: Phantoms.TTerm String -> Phantoms.TTerm Errors.DecodingError -decodingError x = - Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Phantoms.unTTerm x)})) - -errorChecking :: Phantoms.TTerm Checking.CheckingError -> Phantoms.TTerm Errors.Error -errorChecking x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.Error"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "checking"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -errorDecoding :: Phantoms.TTerm Errors.DecodingError -> Phantoms.TTerm Errors.Error -errorDecoding x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.Error"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "decoding"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -errorDuplicateBinding :: Phantoms.TTerm Core_.DuplicateBindingError -> Phantoms.TTerm Errors.Error -errorDuplicateBinding x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.Error"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "duplicateBinding"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -errorDuplicateField :: Phantoms.TTerm Core_.DuplicateFieldError -> Phantoms.TTerm Errors.Error -errorDuplicateField x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.Error"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "duplicateField"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -errorOther :: Phantoms.TTerm Errors.OtherError -> Phantoms.TTerm Errors.Error -errorOther x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.Error"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "other"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -errorUndefinedField :: Phantoms.TTerm Core_.UndefinedFieldError -> Phantoms.TTerm Errors.Error -errorUndefinedField x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.Error"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "undefinedField"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -errorUndefinedTermVariable :: Phantoms.TTerm Core_.UndefinedTermVariableError -> Phantoms.TTerm Errors.Error -errorUndefinedTermVariable x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.Error"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "undefinedTermVariable"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -errorUnexpectedTermVariant :: Phantoms.TTerm Core_.UnexpectedTermVariantError -> Phantoms.TTerm Errors.Error -errorUnexpectedTermVariant x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.Error"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unexpectedTermVariant"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -errorUnexpectedTypeVariant :: Phantoms.TTerm Core_.UnexpectedTypeVariantError -> Phantoms.TTerm Errors.Error -errorUnexpectedTypeVariant x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.Error"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unexpectedTypeVariant"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -errorUnification :: Phantoms.TTerm Errors.UnificationError -> Phantoms.TTerm Errors.Error -errorUnification x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.Error"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unification"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -errorUntypedTermVariable :: Phantoms.TTerm Core_.UntypedTermVariableError -> Phantoms.TTerm Errors.Error -errorUntypedTermVariable x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.Error"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "untypedTermVariable"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -otherError :: Phantoms.TTerm String -> Phantoms.TTerm Errors.OtherError -otherError x = - Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.OtherError"), - Core.wrappedTermBody = (Phantoms.unTTerm x)})) - -unDecodingError :: Phantoms.TTerm Errors.DecodingError -> Phantoms.TTerm String -unDecodingError x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.errors.DecodingError")))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -unOtherError :: Phantoms.TTerm Errors.OtherError -> Phantoms.TTerm String -unOtherError x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.errors.OtherError")))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -unificationError :: Phantoms.TTerm Core.Type -> Phantoms.TTerm Core.Type -> Phantoms.TTerm String -> Phantoms.TTerm Errors.UnificationError -unificationError leftType rightType message = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.errors.UnificationError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "leftType"), - Core.fieldTerm = (Phantoms.unTTerm leftType)}, - Core.Field { - Core.fieldName = (Core.Name "rightType"), - Core.fieldTerm = (Phantoms.unTTerm rightType)}, - Core.Field { - Core.fieldName = (Core.Name "message"), - Core.fieldTerm = (Phantoms.unTTerm message)}]})) - -unificationErrorLeftType :: Phantoms.TTerm Errors.UnificationError -> Phantoms.TTerm Core.Type -unificationErrorLeftType x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.errors.UnificationError"), - Core.projectionField = (Core.Name "leftType")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -unificationErrorMessage :: Phantoms.TTerm Errors.UnificationError -> Phantoms.TTerm String -unificationErrorMessage x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.errors.UnificationError"), - Core.projectionField = (Core.Name "message")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -unificationErrorRightType :: Phantoms.TTerm Errors.UnificationError -> Phantoms.TTerm Core.Type -unificationErrorRightType x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.errors.UnificationError"), - Core.projectionField = (Core.Name "rightType")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -unificationErrorWithLeftType :: Phantoms.TTerm Errors.UnificationError -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Errors.UnificationError -unificationErrorWithLeftType original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.errors.UnificationError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "leftType"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "rightType"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.errors.UnificationError"), - Core.projectionField = (Core.Name "rightType")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "message"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.errors.UnificationError"), - Core.projectionField = (Core.Name "message")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -unificationErrorWithMessage :: Phantoms.TTerm Errors.UnificationError -> Phantoms.TTerm String -> Phantoms.TTerm Errors.UnificationError -unificationErrorWithMessage original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.errors.UnificationError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "leftType"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.errors.UnificationError"), - Core.projectionField = (Core.Name "leftType")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "rightType"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.errors.UnificationError"), - Core.projectionField = (Core.Name "rightType")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "message"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -unificationErrorWithRightType :: Phantoms.TTerm Errors.UnificationError -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Errors.UnificationError -unificationErrorWithRightType original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.errors.UnificationError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "leftType"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.errors.UnificationError"), - Core.projectionField = (Core.Name "leftType")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "rightType"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "message"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.errors.UnificationError"), - Core.projectionField = (Core.Name "message")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) diff --git a/src/gen-main/haskell/Hydra/Dsl/Ext/Haskell/Syntax.hs b/src/gen-main/haskell/Hydra/Dsl/Ext/Haskell/Syntax.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Dsl/Ext/Haskell/Syntax.hs +++ /dev/null @@ -1,3759 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | DSL functions for hydra.ext.haskell.syntax - -module Hydra.Dsl.Ext.Haskell.Syntax where - -import qualified Hydra.Core as Core -import qualified Hydra.Ext.Haskell.Syntax as Syntax -import qualified Hydra.Phantoms as Phantoms -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -alternative :: Phantoms.TTerm Syntax.Pattern -> Phantoms.TTerm Syntax.CaseRhs -> Phantoms.TTerm (Maybe Syntax.LocalBindings) -> Phantoms.TTerm Syntax.Alternative -alternative pattern rhs binds = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.Alternative"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "pattern"), - Core.fieldTerm = (Phantoms.unTTerm pattern)}, - Core.Field { - Core.fieldName = (Core.Name "rhs"), - Core.fieldTerm = (Phantoms.unTTerm rhs)}, - Core.Field { - Core.fieldName = (Core.Name "binds"), - Core.fieldTerm = (Phantoms.unTTerm binds)}]})) - -alternativeBinds :: Phantoms.TTerm Syntax.Alternative -> Phantoms.TTerm (Maybe Syntax.LocalBindings) -alternativeBinds x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Alternative"), - Core.projectionField = (Core.Name "binds")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -alternativePattern :: Phantoms.TTerm Syntax.Alternative -> Phantoms.TTerm Syntax.Pattern -alternativePattern x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Alternative"), - Core.projectionField = (Core.Name "pattern")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -alternativeRhs :: Phantoms.TTerm Syntax.Alternative -> Phantoms.TTerm Syntax.CaseRhs -alternativeRhs x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Alternative"), - Core.projectionField = (Core.Name "rhs")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -alternativeWithBinds :: Phantoms.TTerm Syntax.Alternative -> Phantoms.TTerm (Maybe Syntax.LocalBindings) -> Phantoms.TTerm Syntax.Alternative -alternativeWithBinds original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.Alternative"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "pattern"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Alternative"), - Core.projectionField = (Core.Name "pattern")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "rhs"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Alternative"), - Core.projectionField = (Core.Name "rhs")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "binds"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -alternativeWithPattern :: Phantoms.TTerm Syntax.Alternative -> Phantoms.TTerm Syntax.Pattern -> Phantoms.TTerm Syntax.Alternative -alternativeWithPattern original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.Alternative"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "pattern"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "rhs"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Alternative"), - Core.projectionField = (Core.Name "rhs")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "binds"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Alternative"), - Core.projectionField = (Core.Name "binds")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -alternativeWithRhs :: Phantoms.TTerm Syntax.Alternative -> Phantoms.TTerm Syntax.CaseRhs -> Phantoms.TTerm Syntax.Alternative -alternativeWithRhs original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.Alternative"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "pattern"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Alternative"), - Core.projectionField = (Core.Name "pattern")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "rhs"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "binds"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Alternative"), - Core.projectionField = (Core.Name "binds")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -applicationDeclarationHead :: Phantoms.TTerm Syntax.DeclarationHead -> Phantoms.TTerm Syntax.Variable -> Phantoms.TTerm Syntax.ApplicationDeclarationHead -applicationDeclarationHead function operand = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.ApplicationDeclarationHead"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "function"), - Core.fieldTerm = (Phantoms.unTTerm function)}, - Core.Field { - Core.fieldName = (Core.Name "operand"), - Core.fieldTerm = (Phantoms.unTTerm operand)}]})) - -applicationDeclarationHeadFunction :: Phantoms.TTerm Syntax.ApplicationDeclarationHead -> Phantoms.TTerm Syntax.DeclarationHead -applicationDeclarationHeadFunction x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.ApplicationDeclarationHead"), - Core.projectionField = (Core.Name "function")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -applicationDeclarationHeadOperand :: Phantoms.TTerm Syntax.ApplicationDeclarationHead -> Phantoms.TTerm Syntax.Variable -applicationDeclarationHeadOperand x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.ApplicationDeclarationHead"), - Core.projectionField = (Core.Name "operand")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -applicationDeclarationHeadWithFunction :: Phantoms.TTerm Syntax.ApplicationDeclarationHead -> Phantoms.TTerm Syntax.DeclarationHead -> Phantoms.TTerm Syntax.ApplicationDeclarationHead -applicationDeclarationHeadWithFunction original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.ApplicationDeclarationHead"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "function"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "operand"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.ApplicationDeclarationHead"), - Core.projectionField = (Core.Name "operand")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -applicationDeclarationHeadWithOperand :: Phantoms.TTerm Syntax.ApplicationDeclarationHead -> Phantoms.TTerm Syntax.Variable -> Phantoms.TTerm Syntax.ApplicationDeclarationHead -applicationDeclarationHeadWithOperand original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.ApplicationDeclarationHead"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "function"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.ApplicationDeclarationHead"), - Core.projectionField = (Core.Name "function")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "operand"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -applicationExpression :: Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.ApplicationExpression -applicationExpression function argument = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.ApplicationExpression"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "function"), - Core.fieldTerm = (Phantoms.unTTerm function)}, - Core.Field { - Core.fieldName = (Core.Name "argument"), - Core.fieldTerm = (Phantoms.unTTerm argument)}]})) - -applicationExpressionArgument :: Phantoms.TTerm Syntax.ApplicationExpression -> Phantoms.TTerm Syntax.Expression -applicationExpressionArgument x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.ApplicationExpression"), - Core.projectionField = (Core.Name "argument")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -applicationExpressionFunction :: Phantoms.TTerm Syntax.ApplicationExpression -> Phantoms.TTerm Syntax.Expression -applicationExpressionFunction x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.ApplicationExpression"), - Core.projectionField = (Core.Name "function")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -applicationExpressionWithArgument :: Phantoms.TTerm Syntax.ApplicationExpression -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.ApplicationExpression -applicationExpressionWithArgument original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.ApplicationExpression"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "function"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.ApplicationExpression"), - Core.projectionField = (Core.Name "function")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "argument"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -applicationExpressionWithFunction :: Phantoms.TTerm Syntax.ApplicationExpression -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.ApplicationExpression -applicationExpressionWithFunction original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.ApplicationExpression"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "function"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "argument"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.ApplicationExpression"), - Core.projectionField = (Core.Name "argument")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -applicationPattern :: Phantoms.TTerm Syntax.Name -> Phantoms.TTerm [Syntax.Pattern] -> Phantoms.TTerm Syntax.ApplicationPattern -applicationPattern name args = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.ApplicationPattern"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm name)}, - Core.Field { - Core.fieldName = (Core.Name "args"), - Core.fieldTerm = (Phantoms.unTTerm args)}]})) - -applicationPatternArgs :: Phantoms.TTerm Syntax.ApplicationPattern -> Phantoms.TTerm [Syntax.Pattern] -applicationPatternArgs x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.ApplicationPattern"), - Core.projectionField = (Core.Name "args")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -applicationPatternName :: Phantoms.TTerm Syntax.ApplicationPattern -> Phantoms.TTerm Syntax.Name -applicationPatternName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.ApplicationPattern"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -applicationPatternWithArgs :: Phantoms.TTerm Syntax.ApplicationPattern -> Phantoms.TTerm [Syntax.Pattern] -> Phantoms.TTerm Syntax.ApplicationPattern -applicationPatternWithArgs original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.ApplicationPattern"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.ApplicationPattern"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "args"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -applicationPatternWithName :: Phantoms.TTerm Syntax.ApplicationPattern -> Phantoms.TTerm Syntax.Name -> Phantoms.TTerm Syntax.ApplicationPattern -applicationPatternWithName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.ApplicationPattern"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "args"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.ApplicationPattern"), - Core.projectionField = (Core.Name "args")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -applicationType :: Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.ApplicationType -applicationType context argument = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.ApplicationType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "context"), - Core.fieldTerm = (Phantoms.unTTerm context)}, - Core.Field { - Core.fieldName = (Core.Name "argument"), - Core.fieldTerm = (Phantoms.unTTerm argument)}]})) - -applicationTypeArgument :: Phantoms.TTerm Syntax.ApplicationType -> Phantoms.TTerm Syntax.Type -applicationTypeArgument x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.ApplicationType"), - Core.projectionField = (Core.Name "argument")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -applicationTypeContext :: Phantoms.TTerm Syntax.ApplicationType -> Phantoms.TTerm Syntax.Type -applicationTypeContext x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.ApplicationType"), - Core.projectionField = (Core.Name "context")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -applicationTypeWithArgument :: Phantoms.TTerm Syntax.ApplicationType -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.ApplicationType -applicationTypeWithArgument original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.ApplicationType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "context"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.ApplicationType"), - Core.projectionField = (Core.Name "context")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "argument"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -applicationTypeWithContext :: Phantoms.TTerm Syntax.ApplicationType -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.ApplicationType -applicationTypeWithContext original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.ApplicationType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "context"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "argument"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.ApplicationType"), - Core.projectionField = (Core.Name "argument")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -asPattern :: Phantoms.TTerm Syntax.Name -> Phantoms.TTerm Syntax.Pattern -> Phantoms.TTerm Syntax.AsPattern -asPattern name inner = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.AsPattern"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm name)}, - Core.Field { - Core.fieldName = (Core.Name "inner"), - Core.fieldTerm = (Phantoms.unTTerm inner)}]})) - -asPatternInner :: Phantoms.TTerm Syntax.AsPattern -> Phantoms.TTerm Syntax.Pattern -asPatternInner x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.AsPattern"), - Core.projectionField = (Core.Name "inner")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -asPatternName :: Phantoms.TTerm Syntax.AsPattern -> Phantoms.TTerm Syntax.Name -asPatternName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.AsPattern"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -asPatternWithInner :: Phantoms.TTerm Syntax.AsPattern -> Phantoms.TTerm Syntax.Pattern -> Phantoms.TTerm Syntax.AsPattern -asPatternWithInner original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.AsPattern"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.AsPattern"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "inner"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -asPatternWithName :: Phantoms.TTerm Syntax.AsPattern -> Phantoms.TTerm Syntax.Name -> Phantoms.TTerm Syntax.AsPattern -asPatternWithName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.AsPattern"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "inner"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.AsPattern"), - Core.projectionField = (Core.Name "inner")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -assertionClass :: Phantoms.TTerm Syntax.ClassAssertion -> Phantoms.TTerm Syntax.Assertion -assertionClass x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Assertion"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "class"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -assertionTuple :: Phantoms.TTerm [Syntax.Assertion] -> Phantoms.TTerm Syntax.Assertion -assertionTuple x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Assertion"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "tuple"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -caseExpression :: Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm [Syntax.Alternative] -> Phantoms.TTerm Syntax.CaseExpression -caseExpression case_ alternatives = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.CaseExpression"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "case"), - Core.fieldTerm = (Phantoms.unTTerm case_)}, - Core.Field { - Core.fieldName = (Core.Name "alternatives"), - Core.fieldTerm = (Phantoms.unTTerm alternatives)}]})) - -caseExpressionAlternatives :: Phantoms.TTerm Syntax.CaseExpression -> Phantoms.TTerm [Syntax.Alternative] -caseExpressionAlternatives x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.CaseExpression"), - Core.projectionField = (Core.Name "alternatives")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -caseExpressionCase :: Phantoms.TTerm Syntax.CaseExpression -> Phantoms.TTerm Syntax.Expression -caseExpressionCase x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.CaseExpression"), - Core.projectionField = (Core.Name "case")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -caseExpressionWithAlternatives :: Phantoms.TTerm Syntax.CaseExpression -> Phantoms.TTerm [Syntax.Alternative] -> Phantoms.TTerm Syntax.CaseExpression -caseExpressionWithAlternatives original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.CaseExpression"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "case"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.CaseExpression"), - Core.projectionField = (Core.Name "case")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "alternatives"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -caseExpressionWithCase :: Phantoms.TTerm Syntax.CaseExpression -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.CaseExpression -caseExpressionWithCase original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.CaseExpression"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "case"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "alternatives"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.CaseExpression"), - Core.projectionField = (Core.Name "alternatives")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -caseRhs :: Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.CaseRhs -caseRhs x = - Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.ext.haskell.syntax.CaseRhs"), - Core.wrappedTermBody = (Phantoms.unTTerm x)})) - -classAssertion :: Phantoms.TTerm Syntax.Name -> Phantoms.TTerm [Syntax.Type] -> Phantoms.TTerm Syntax.ClassAssertion -classAssertion name types = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.ClassAssertion"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm name)}, - Core.Field { - Core.fieldName = (Core.Name "types"), - Core.fieldTerm = (Phantoms.unTTerm types)}]})) - -classAssertionName :: Phantoms.TTerm Syntax.ClassAssertion -> Phantoms.TTerm Syntax.Name -classAssertionName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.ClassAssertion"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -classAssertionTypes :: Phantoms.TTerm Syntax.ClassAssertion -> Phantoms.TTerm [Syntax.Type] -classAssertionTypes x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.ClassAssertion"), - Core.projectionField = (Core.Name "types")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -classAssertionWithName :: Phantoms.TTerm Syntax.ClassAssertion -> Phantoms.TTerm Syntax.Name -> Phantoms.TTerm Syntax.ClassAssertion -classAssertionWithName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.ClassAssertion"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "types"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.ClassAssertion"), - Core.projectionField = (Core.Name "types")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -classAssertionWithTypes :: Phantoms.TTerm Syntax.ClassAssertion -> Phantoms.TTerm [Syntax.Type] -> Phantoms.TTerm Syntax.ClassAssertion -classAssertionWithTypes original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.ClassAssertion"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.ClassAssertion"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "types"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -constructRecordExpression :: Phantoms.TTerm Syntax.Name -> Phantoms.TTerm [Syntax.FieldUpdate] -> Phantoms.TTerm Syntax.ConstructRecordExpression -constructRecordExpression name fields = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.ConstructRecordExpression"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm name)}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Phantoms.unTTerm fields)}]})) - -constructRecordExpressionFields :: Phantoms.TTerm Syntax.ConstructRecordExpression -> Phantoms.TTerm [Syntax.FieldUpdate] -constructRecordExpressionFields x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.ConstructRecordExpression"), - Core.projectionField = (Core.Name "fields")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -constructRecordExpressionName :: Phantoms.TTerm Syntax.ConstructRecordExpression -> Phantoms.TTerm Syntax.Name -constructRecordExpressionName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.ConstructRecordExpression"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -constructRecordExpressionWithFields :: Phantoms.TTerm Syntax.ConstructRecordExpression -> Phantoms.TTerm [Syntax.FieldUpdate] -> Phantoms.TTerm Syntax.ConstructRecordExpression -constructRecordExpressionWithFields original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.ConstructRecordExpression"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.ConstructRecordExpression"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -constructRecordExpressionWithName :: Phantoms.TTerm Syntax.ConstructRecordExpression -> Phantoms.TTerm Syntax.Name -> Phantoms.TTerm Syntax.ConstructRecordExpression -constructRecordExpressionWithName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.ConstructRecordExpression"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.ConstructRecordExpression"), - Core.projectionField = (Core.Name "fields")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -constructorOrdinary :: Phantoms.TTerm Syntax.OrdinaryConstructor -> Phantoms.TTerm Syntax.Constructor -constructorOrdinary x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Constructor"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "ordinary"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -constructorRecord :: Phantoms.TTerm Syntax.RecordConstructor -> Phantoms.TTerm Syntax.Constructor -constructorRecord x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Constructor"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -constructorWithComments :: Phantoms.TTerm Syntax.Constructor -> Phantoms.TTerm (Maybe String) -> Phantoms.TTerm Syntax.ConstructorWithComments -constructorWithComments body comments = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.ConstructorWithComments"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Phantoms.unTTerm body)}, - Core.Field { - Core.fieldName = (Core.Name "comments"), - Core.fieldTerm = (Phantoms.unTTerm comments)}]})) - -constructorWithCommentsBody :: Phantoms.TTerm Syntax.ConstructorWithComments -> Phantoms.TTerm Syntax.Constructor -constructorWithCommentsBody x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.ConstructorWithComments"), - Core.projectionField = (Core.Name "body")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -constructorWithCommentsComments :: Phantoms.TTerm Syntax.ConstructorWithComments -> Phantoms.TTerm (Maybe String) -constructorWithCommentsComments x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.ConstructorWithComments"), - Core.projectionField = (Core.Name "comments")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -constructorWithCommentsWithBody :: Phantoms.TTerm Syntax.ConstructorWithComments -> Phantoms.TTerm Syntax.Constructor -> Phantoms.TTerm Syntax.ConstructorWithComments -constructorWithCommentsWithBody original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.ConstructorWithComments"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "comments"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.ConstructorWithComments"), - Core.projectionField = (Core.Name "comments")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -constructorWithCommentsWithComments :: Phantoms.TTerm Syntax.ConstructorWithComments -> Phantoms.TTerm (Maybe String) -> Phantoms.TTerm Syntax.ConstructorWithComments -constructorWithCommentsWithComments original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.ConstructorWithComments"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.ConstructorWithComments"), - Core.projectionField = (Core.Name "body")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "comments"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -contextType :: Phantoms.TTerm Syntax.Assertion -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.ContextType -contextType ctx type_ = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.ContextType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "ctx"), - Core.fieldTerm = (Phantoms.unTTerm ctx)}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Phantoms.unTTerm type_)}]})) - -contextTypeCtx :: Phantoms.TTerm Syntax.ContextType -> Phantoms.TTerm Syntax.Assertion -contextTypeCtx x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.ContextType"), - Core.projectionField = (Core.Name "ctx")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -contextTypeType :: Phantoms.TTerm Syntax.ContextType -> Phantoms.TTerm Syntax.Type -contextTypeType x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.ContextType"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -contextTypeWithCtx :: Phantoms.TTerm Syntax.ContextType -> Phantoms.TTerm Syntax.Assertion -> Phantoms.TTerm Syntax.ContextType -contextTypeWithCtx original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.ContextType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "ctx"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.ContextType"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -contextTypeWithType :: Phantoms.TTerm Syntax.ContextType -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.ContextType -contextTypeWithType original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.ContextType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "ctx"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.ContextType"), - Core.projectionField = (Core.Name "ctx")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -dataDeclaration :: Phantoms.TTerm Syntax.DataOrNewtype -> Phantoms.TTerm [Syntax.Assertion] -> Phantoms.TTerm Syntax.DeclarationHead -> Phantoms.TTerm [Syntax.ConstructorWithComments] -> Phantoms.TTerm [Syntax.Deriving] -> Phantoms.TTerm Syntax.DataDeclaration -dataDeclaration keyword context head constructors deriving_ = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.DataDeclaration"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "keyword"), - Core.fieldTerm = (Phantoms.unTTerm keyword)}, - Core.Field { - Core.fieldName = (Core.Name "context"), - Core.fieldTerm = (Phantoms.unTTerm context)}, - Core.Field { - Core.fieldName = (Core.Name "head"), - Core.fieldTerm = (Phantoms.unTTerm head)}, - Core.Field { - Core.fieldName = (Core.Name "constructors"), - Core.fieldTerm = (Phantoms.unTTerm constructors)}, - Core.Field { - Core.fieldName = (Core.Name "deriving"), - Core.fieldTerm = (Phantoms.unTTerm deriving_)}]})) - -dataDeclarationConstructors :: Phantoms.TTerm Syntax.DataDeclaration -> Phantoms.TTerm [Syntax.ConstructorWithComments] -dataDeclarationConstructors x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.DataDeclaration"), - Core.projectionField = (Core.Name "constructors")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -dataDeclarationContext :: Phantoms.TTerm Syntax.DataDeclaration -> Phantoms.TTerm [Syntax.Assertion] -dataDeclarationContext x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.DataDeclaration"), - Core.projectionField = (Core.Name "context")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -dataDeclarationDeriving :: Phantoms.TTerm Syntax.DataDeclaration -> Phantoms.TTerm [Syntax.Deriving] -dataDeclarationDeriving x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.DataDeclaration"), - Core.projectionField = (Core.Name "deriving")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -dataDeclarationHead :: Phantoms.TTerm Syntax.DataDeclaration -> Phantoms.TTerm Syntax.DeclarationHead -dataDeclarationHead x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.DataDeclaration"), - Core.projectionField = (Core.Name "head")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -dataDeclarationKeyword :: Phantoms.TTerm Syntax.DataDeclaration -> Phantoms.TTerm Syntax.DataOrNewtype -dataDeclarationKeyword x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.DataDeclaration"), - Core.projectionField = (Core.Name "keyword")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -dataDeclarationWithConstructors :: Phantoms.TTerm Syntax.DataDeclaration -> Phantoms.TTerm [Syntax.ConstructorWithComments] -> Phantoms.TTerm Syntax.DataDeclaration -dataDeclarationWithConstructors original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.DataDeclaration"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "keyword"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.DataDeclaration"), - Core.projectionField = (Core.Name "keyword")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "context"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.DataDeclaration"), - Core.projectionField = (Core.Name "context")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "head"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.DataDeclaration"), - Core.projectionField = (Core.Name "head")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "constructors"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "deriving"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.DataDeclaration"), - Core.projectionField = (Core.Name "deriving")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -dataDeclarationWithContext :: Phantoms.TTerm Syntax.DataDeclaration -> Phantoms.TTerm [Syntax.Assertion] -> Phantoms.TTerm Syntax.DataDeclaration -dataDeclarationWithContext original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.DataDeclaration"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "keyword"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.DataDeclaration"), - Core.projectionField = (Core.Name "keyword")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "context"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "head"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.DataDeclaration"), - Core.projectionField = (Core.Name "head")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "constructors"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.DataDeclaration"), - Core.projectionField = (Core.Name "constructors")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "deriving"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.DataDeclaration"), - Core.projectionField = (Core.Name "deriving")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -dataDeclarationWithDeriving :: Phantoms.TTerm Syntax.DataDeclaration -> Phantoms.TTerm [Syntax.Deriving] -> Phantoms.TTerm Syntax.DataDeclaration -dataDeclarationWithDeriving original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.DataDeclaration"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "keyword"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.DataDeclaration"), - Core.projectionField = (Core.Name "keyword")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "context"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.DataDeclaration"), - Core.projectionField = (Core.Name "context")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "head"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.DataDeclaration"), - Core.projectionField = (Core.Name "head")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "constructors"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.DataDeclaration"), - Core.projectionField = (Core.Name "constructors")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "deriving"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -dataDeclarationWithHead :: Phantoms.TTerm Syntax.DataDeclaration -> Phantoms.TTerm Syntax.DeclarationHead -> Phantoms.TTerm Syntax.DataDeclaration -dataDeclarationWithHead original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.DataDeclaration"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "keyword"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.DataDeclaration"), - Core.projectionField = (Core.Name "keyword")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "context"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.DataDeclaration"), - Core.projectionField = (Core.Name "context")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "head"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "constructors"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.DataDeclaration"), - Core.projectionField = (Core.Name "constructors")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "deriving"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.DataDeclaration"), - Core.projectionField = (Core.Name "deriving")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -dataDeclarationWithKeyword :: Phantoms.TTerm Syntax.DataDeclaration -> Phantoms.TTerm Syntax.DataOrNewtype -> Phantoms.TTerm Syntax.DataDeclaration -dataDeclarationWithKeyword original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.DataDeclaration"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "keyword"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "context"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.DataDeclaration"), - Core.projectionField = (Core.Name "context")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "head"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.DataDeclaration"), - Core.projectionField = (Core.Name "head")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "constructors"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.DataDeclaration"), - Core.projectionField = (Core.Name "constructors")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "deriving"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.DataDeclaration"), - Core.projectionField = (Core.Name "deriving")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -dataOrNewtypeData :: Phantoms.TTerm Syntax.DataOrNewtype -dataOrNewtypeData = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.DataOrNewtype"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "data"), - Core.fieldTerm = Core.TermUnit}})) - -dataOrNewtypeNewtype :: Phantoms.TTerm Syntax.DataOrNewtype -dataOrNewtypeNewtype = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.DataOrNewtype"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "newtype"), - Core.fieldTerm = Core.TermUnit}})) - -declarationData :: Phantoms.TTerm Syntax.DataDeclaration -> Phantoms.TTerm Syntax.Declaration -declarationData x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Declaration"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "data"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -declarationHeadApplication :: Phantoms.TTerm Syntax.ApplicationDeclarationHead -> Phantoms.TTerm Syntax.DeclarationHead -declarationHeadApplication x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.DeclarationHead"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "application"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -declarationHeadParens :: Phantoms.TTerm Syntax.DeclarationHead -> Phantoms.TTerm Syntax.DeclarationHead -declarationHeadParens x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.DeclarationHead"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "parens"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -declarationHeadSimple :: Phantoms.TTerm Syntax.Name -> Phantoms.TTerm Syntax.DeclarationHead -declarationHeadSimple x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.DeclarationHead"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "simple"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -declarationType :: Phantoms.TTerm Syntax.TypeDeclaration -> Phantoms.TTerm Syntax.Declaration -declarationType x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Declaration"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -declarationTypedBinding :: Phantoms.TTerm Syntax.TypedBinding -> Phantoms.TTerm Syntax.Declaration -declarationTypedBinding x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Declaration"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "typedBinding"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -declarationValueBinding :: Phantoms.TTerm Syntax.ValueBinding -> Phantoms.TTerm Syntax.Declaration -declarationValueBinding x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Declaration"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "valueBinding"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -declarationWithComments :: Phantoms.TTerm Syntax.Declaration -> Phantoms.TTerm (Maybe String) -> Phantoms.TTerm Syntax.DeclarationWithComments -declarationWithComments body comments = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.DeclarationWithComments"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Phantoms.unTTerm body)}, - Core.Field { - Core.fieldName = (Core.Name "comments"), - Core.fieldTerm = (Phantoms.unTTerm comments)}]})) - -declarationWithCommentsBody :: Phantoms.TTerm Syntax.DeclarationWithComments -> Phantoms.TTerm Syntax.Declaration -declarationWithCommentsBody x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.DeclarationWithComments"), - Core.projectionField = (Core.Name "body")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -declarationWithCommentsComments :: Phantoms.TTerm Syntax.DeclarationWithComments -> Phantoms.TTerm (Maybe String) -declarationWithCommentsComments x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.DeclarationWithComments"), - Core.projectionField = (Core.Name "comments")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -declarationWithCommentsWithBody :: Phantoms.TTerm Syntax.DeclarationWithComments -> Phantoms.TTerm Syntax.Declaration -> Phantoms.TTerm Syntax.DeclarationWithComments -declarationWithCommentsWithBody original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.DeclarationWithComments"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "comments"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.DeclarationWithComments"), - Core.projectionField = (Core.Name "comments")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -declarationWithCommentsWithComments :: Phantoms.TTerm Syntax.DeclarationWithComments -> Phantoms.TTerm (Maybe String) -> Phantoms.TTerm Syntax.DeclarationWithComments -declarationWithCommentsWithComments original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.DeclarationWithComments"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.DeclarationWithComments"), - Core.projectionField = (Core.Name "body")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "comments"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -deriving_ :: Phantoms.TTerm [Syntax.Name] -> Phantoms.TTerm Syntax.Deriving -deriving_ x = - Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.ext.haskell.syntax.Deriving"), - Core.wrappedTermBody = (Phantoms.unTTerm x)})) - -exportDeclaration :: Phantoms.TTerm Syntax.ImportExportSpec -> Phantoms.TTerm Syntax.Export -exportDeclaration x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Export"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "declaration"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -exportModule :: Phantoms.TTerm Syntax.ModuleName -> Phantoms.TTerm Syntax.Export -exportModule x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Export"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "module"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -expressionApplication :: Phantoms.TTerm Syntax.ApplicationExpression -> Phantoms.TTerm Syntax.Expression -expressionApplication x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Expression"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "application"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -expressionCase :: Phantoms.TTerm Syntax.CaseExpression -> Phantoms.TTerm Syntax.Expression -expressionCase x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Expression"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "case"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -expressionConstructRecord :: Phantoms.TTerm Syntax.ConstructRecordExpression -> Phantoms.TTerm Syntax.Expression -expressionConstructRecord x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Expression"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "constructRecord"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -expressionDo :: Phantoms.TTerm [Syntax.Statement] -> Phantoms.TTerm Syntax.Expression -expressionDo x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Expression"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "do"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -expressionIf :: Phantoms.TTerm Syntax.IfExpression -> Phantoms.TTerm Syntax.Expression -expressionIf x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Expression"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "if"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -expressionInfixApplication :: Phantoms.TTerm Syntax.InfixApplicationExpression -> Phantoms.TTerm Syntax.Expression -expressionInfixApplication x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Expression"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "infixApplication"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -expressionLambda :: Phantoms.TTerm Syntax.LambdaExpression -> Phantoms.TTerm Syntax.Expression -expressionLambda x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Expression"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "lambda"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -expressionLeftSection :: Phantoms.TTerm Syntax.SectionExpression -> Phantoms.TTerm Syntax.Expression -expressionLeftSection x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Expression"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "leftSection"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -expressionLet :: Phantoms.TTerm Syntax.LetExpression -> Phantoms.TTerm Syntax.Expression -expressionLet x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Expression"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "let"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -expressionList :: Phantoms.TTerm [Syntax.Expression] -> Phantoms.TTerm Syntax.Expression -expressionList x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Expression"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -expressionLiteral :: Phantoms.TTerm Syntax.Literal -> Phantoms.TTerm Syntax.Expression -expressionLiteral x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Expression"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -expressionParens :: Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.Expression -expressionParens x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Expression"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "parens"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -expressionPrefixApplication :: Phantoms.TTerm Syntax.PrefixApplicationExpression -> Phantoms.TTerm Syntax.Expression -expressionPrefixApplication x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Expression"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "prefixApplication"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -expressionRightSection :: Phantoms.TTerm Syntax.SectionExpression -> Phantoms.TTerm Syntax.Expression -expressionRightSection x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Expression"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "rightSection"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -expressionTuple :: Phantoms.TTerm [Syntax.Expression] -> Phantoms.TTerm Syntax.Expression -expressionTuple x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Expression"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "tuple"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -expressionTypeSignature :: Phantoms.TTerm Syntax.TypeSignatureExpression -> Phantoms.TTerm Syntax.Expression -expressionTypeSignature x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Expression"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "typeSignature"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -expressionUpdateRecord :: Phantoms.TTerm Syntax.UpdateRecordExpression -> Phantoms.TTerm Syntax.Expression -expressionUpdateRecord x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Expression"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "updateRecord"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -expressionVariable :: Phantoms.TTerm Syntax.Name -> Phantoms.TTerm Syntax.Expression -expressionVariable x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Expression"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "variable"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -field :: Phantoms.TTerm Syntax.Name -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.Field -field name type_ = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm name)}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Phantoms.unTTerm type_)}]})) - -fieldName :: Phantoms.TTerm Syntax.Field -> Phantoms.TTerm Syntax.Name -fieldName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Field"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -fieldType :: Phantoms.TTerm Syntax.Field -> Phantoms.TTerm Syntax.Type -fieldType x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Field"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -fieldUpdate :: Phantoms.TTerm Syntax.Name -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.FieldUpdate -fieldUpdate name value = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.FieldUpdate"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm name)}, - Core.Field { - Core.fieldName = (Core.Name "value"), - Core.fieldTerm = (Phantoms.unTTerm value)}]})) - -fieldUpdateName :: Phantoms.TTerm Syntax.FieldUpdate -> Phantoms.TTerm Syntax.Name -fieldUpdateName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.FieldUpdate"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -fieldUpdateValue :: Phantoms.TTerm Syntax.FieldUpdate -> Phantoms.TTerm Syntax.Expression -fieldUpdateValue x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.FieldUpdate"), - Core.projectionField = (Core.Name "value")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -fieldUpdateWithName :: Phantoms.TTerm Syntax.FieldUpdate -> Phantoms.TTerm Syntax.Name -> Phantoms.TTerm Syntax.FieldUpdate -fieldUpdateWithName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.FieldUpdate"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "value"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.FieldUpdate"), - Core.projectionField = (Core.Name "value")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -fieldUpdateWithValue :: Phantoms.TTerm Syntax.FieldUpdate -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.FieldUpdate -fieldUpdateWithValue original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.FieldUpdate"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.FieldUpdate"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "value"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -fieldWithComments :: Phantoms.TTerm Syntax.Field -> Phantoms.TTerm (Maybe String) -> Phantoms.TTerm Syntax.FieldWithComments -fieldWithComments field comments = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.FieldWithComments"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Phantoms.unTTerm field)}, - Core.Field { - Core.fieldName = (Core.Name "comments"), - Core.fieldTerm = (Phantoms.unTTerm comments)}]})) - -fieldWithCommentsComments :: Phantoms.TTerm Syntax.FieldWithComments -> Phantoms.TTerm (Maybe String) -fieldWithCommentsComments x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.FieldWithComments"), - Core.projectionField = (Core.Name "comments")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -fieldWithCommentsField :: Phantoms.TTerm Syntax.FieldWithComments -> Phantoms.TTerm Syntax.Field -fieldWithCommentsField x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.FieldWithComments"), - Core.projectionField = (Core.Name "field")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -fieldWithCommentsWithComments :: Phantoms.TTerm Syntax.FieldWithComments -> Phantoms.TTerm (Maybe String) -> Phantoms.TTerm Syntax.FieldWithComments -fieldWithCommentsWithComments original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.FieldWithComments"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.FieldWithComments"), - Core.projectionField = (Core.Name "field")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "comments"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -fieldWithCommentsWithField :: Phantoms.TTerm Syntax.FieldWithComments -> Phantoms.TTerm Syntax.Field -> Phantoms.TTerm Syntax.FieldWithComments -fieldWithCommentsWithField original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.FieldWithComments"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "comments"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.FieldWithComments"), - Core.projectionField = (Core.Name "comments")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -fieldWithName :: Phantoms.TTerm Syntax.Field -> Phantoms.TTerm Syntax.Name -> Phantoms.TTerm Syntax.Field -fieldWithName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Field"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -fieldWithType :: Phantoms.TTerm Syntax.Field -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.Field -fieldWithType original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Field"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -functionType :: Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.FunctionType -functionType domain codomain = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.FunctionType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "domain"), - Core.fieldTerm = (Phantoms.unTTerm domain)}, - Core.Field { - Core.fieldName = (Core.Name "codomain"), - Core.fieldTerm = (Phantoms.unTTerm codomain)}]})) - -functionTypeCodomain :: Phantoms.TTerm Syntax.FunctionType -> Phantoms.TTerm Syntax.Type -functionTypeCodomain x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.FunctionType"), - Core.projectionField = (Core.Name "codomain")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -functionTypeDomain :: Phantoms.TTerm Syntax.FunctionType -> Phantoms.TTerm Syntax.Type -functionTypeDomain x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.FunctionType"), - Core.projectionField = (Core.Name "domain")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -functionTypeWithCodomain :: Phantoms.TTerm Syntax.FunctionType -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.FunctionType -functionTypeWithCodomain original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.FunctionType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "domain"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.FunctionType"), - Core.projectionField = (Core.Name "domain")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "codomain"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -functionTypeWithDomain :: Phantoms.TTerm Syntax.FunctionType -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.FunctionType -functionTypeWithDomain original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.FunctionType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "domain"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "codomain"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.FunctionType"), - Core.projectionField = (Core.Name "codomain")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -ifExpression :: Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.IfExpression -ifExpression condition then_ else_ = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.IfExpression"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "condition"), - Core.fieldTerm = (Phantoms.unTTerm condition)}, - Core.Field { - Core.fieldName = (Core.Name "then"), - Core.fieldTerm = (Phantoms.unTTerm then_)}, - Core.Field { - Core.fieldName = (Core.Name "else"), - Core.fieldTerm = (Phantoms.unTTerm else_)}]})) - -ifExpressionCondition :: Phantoms.TTerm Syntax.IfExpression -> Phantoms.TTerm Syntax.Expression -ifExpressionCondition x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.IfExpression"), - Core.projectionField = (Core.Name "condition")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -ifExpressionElse :: Phantoms.TTerm Syntax.IfExpression -> Phantoms.TTerm Syntax.Expression -ifExpressionElse x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.IfExpression"), - Core.projectionField = (Core.Name "else")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -ifExpressionThen :: Phantoms.TTerm Syntax.IfExpression -> Phantoms.TTerm Syntax.Expression -ifExpressionThen x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.IfExpression"), - Core.projectionField = (Core.Name "then")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -ifExpressionWithCondition :: Phantoms.TTerm Syntax.IfExpression -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.IfExpression -ifExpressionWithCondition original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.IfExpression"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "condition"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "then"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.IfExpression"), - Core.projectionField = (Core.Name "then")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "else"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.IfExpression"), - Core.projectionField = (Core.Name "else")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -ifExpressionWithElse :: Phantoms.TTerm Syntax.IfExpression -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.IfExpression -ifExpressionWithElse original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.IfExpression"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "condition"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.IfExpression"), - Core.projectionField = (Core.Name "condition")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "then"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.IfExpression"), - Core.projectionField = (Core.Name "then")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "else"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -ifExpressionWithThen :: Phantoms.TTerm Syntax.IfExpression -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.IfExpression -ifExpressionWithThen original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.IfExpression"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "condition"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.IfExpression"), - Core.projectionField = (Core.Name "condition")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "then"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "else"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.IfExpression"), - Core.projectionField = (Core.Name "else")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -import_ :: Phantoms.TTerm Bool -> Phantoms.TTerm Syntax.ModuleName -> Phantoms.TTerm (Maybe Syntax.ModuleName) -> Phantoms.TTerm (Maybe Syntax.SpecImport) -> Phantoms.TTerm Syntax.Import -import_ qualified module_ as spec = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.Import"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "qualified"), - Core.fieldTerm = (Phantoms.unTTerm qualified)}, - Core.Field { - Core.fieldName = (Core.Name "module"), - Core.fieldTerm = (Phantoms.unTTerm module_)}, - Core.Field { - Core.fieldName = (Core.Name "as"), - Core.fieldTerm = (Phantoms.unTTerm as)}, - Core.Field { - Core.fieldName = (Core.Name "spec"), - Core.fieldTerm = (Phantoms.unTTerm spec)}]})) - -importAs :: Phantoms.TTerm Syntax.Import -> Phantoms.TTerm (Maybe Syntax.ModuleName) -importAs x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Import"), - Core.projectionField = (Core.Name "as")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -importExportSpec :: Phantoms.TTerm (Maybe Syntax.ImportModifier) -> Phantoms.TTerm Syntax.Name -> Phantoms.TTerm (Maybe Syntax.SubspecImportExportSpec) -> Phantoms.TTerm Syntax.ImportExportSpec -importExportSpec modifier name subspec = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.ImportExportSpec"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "modifier"), - Core.fieldTerm = (Phantoms.unTTerm modifier)}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm name)}, - Core.Field { - Core.fieldName = (Core.Name "subspec"), - Core.fieldTerm = (Phantoms.unTTerm subspec)}]})) - -importExportSpecModifier :: Phantoms.TTerm Syntax.ImportExportSpec -> Phantoms.TTerm (Maybe Syntax.ImportModifier) -importExportSpecModifier x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.ImportExportSpec"), - Core.projectionField = (Core.Name "modifier")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -importExportSpecName :: Phantoms.TTerm Syntax.ImportExportSpec -> Phantoms.TTerm Syntax.Name -importExportSpecName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.ImportExportSpec"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -importExportSpecSubspec :: Phantoms.TTerm Syntax.ImportExportSpec -> Phantoms.TTerm (Maybe Syntax.SubspecImportExportSpec) -importExportSpecSubspec x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.ImportExportSpec"), - Core.projectionField = (Core.Name "subspec")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -importExportSpecWithModifier :: Phantoms.TTerm Syntax.ImportExportSpec -> Phantoms.TTerm (Maybe Syntax.ImportModifier) -> Phantoms.TTerm Syntax.ImportExportSpec -importExportSpecWithModifier original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.ImportExportSpec"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "modifier"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.ImportExportSpec"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "subspec"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.ImportExportSpec"), - Core.projectionField = (Core.Name "subspec")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -importExportSpecWithName :: Phantoms.TTerm Syntax.ImportExportSpec -> Phantoms.TTerm Syntax.Name -> Phantoms.TTerm Syntax.ImportExportSpec -importExportSpecWithName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.ImportExportSpec"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "modifier"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.ImportExportSpec"), - Core.projectionField = (Core.Name "modifier")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "subspec"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.ImportExportSpec"), - Core.projectionField = (Core.Name "subspec")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -importExportSpecWithSubspec :: Phantoms.TTerm Syntax.ImportExportSpec -> Phantoms.TTerm (Maybe Syntax.SubspecImportExportSpec) -> Phantoms.TTerm Syntax.ImportExportSpec -importExportSpecWithSubspec original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.ImportExportSpec"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "modifier"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.ImportExportSpec"), - Core.projectionField = (Core.Name "modifier")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.ImportExportSpec"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "subspec"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -importModifierPattern :: Phantoms.TTerm Syntax.ImportModifier -importModifierPattern = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.ImportModifier"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "pattern"), - Core.fieldTerm = Core.TermUnit}})) - -importModifierType :: Phantoms.TTerm Syntax.ImportModifier -importModifierType = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.ImportModifier"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = Core.TermUnit}})) - -importModule :: Phantoms.TTerm Syntax.Import -> Phantoms.TTerm Syntax.ModuleName -importModule x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Import"), - Core.projectionField = (Core.Name "module")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -importQualified :: Phantoms.TTerm Syntax.Import -> Phantoms.TTerm Bool -importQualified x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Import"), - Core.projectionField = (Core.Name "qualified")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -importSpec :: Phantoms.TTerm Syntax.Import -> Phantoms.TTerm (Maybe Syntax.SpecImport) -importSpec x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Import"), - Core.projectionField = (Core.Name "spec")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -importWithAs :: Phantoms.TTerm Syntax.Import -> Phantoms.TTerm (Maybe Syntax.ModuleName) -> Phantoms.TTerm Syntax.Import -importWithAs original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.Import"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "qualified"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Import"), - Core.projectionField = (Core.Name "qualified")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "module"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Import"), - Core.projectionField = (Core.Name "module")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "as"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "spec"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Import"), - Core.projectionField = (Core.Name "spec")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -importWithModule :: Phantoms.TTerm Syntax.Import -> Phantoms.TTerm Syntax.ModuleName -> Phantoms.TTerm Syntax.Import -importWithModule original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.Import"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "qualified"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Import"), - Core.projectionField = (Core.Name "qualified")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "module"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "as"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Import"), - Core.projectionField = (Core.Name "as")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "spec"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Import"), - Core.projectionField = (Core.Name "spec")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -importWithQualified :: Phantoms.TTerm Syntax.Import -> Phantoms.TTerm Bool -> Phantoms.TTerm Syntax.Import -importWithQualified original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.Import"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "qualified"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "module"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Import"), - Core.projectionField = (Core.Name "module")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "as"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Import"), - Core.projectionField = (Core.Name "as")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "spec"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Import"), - Core.projectionField = (Core.Name "spec")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -importWithSpec :: Phantoms.TTerm Syntax.Import -> Phantoms.TTerm (Maybe Syntax.SpecImport) -> Phantoms.TTerm Syntax.Import -importWithSpec original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.Import"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "qualified"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Import"), - Core.projectionField = (Core.Name "qualified")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "module"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Import"), - Core.projectionField = (Core.Name "module")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "as"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Import"), - Core.projectionField = (Core.Name "as")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "spec"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -infixApplicationExpression :: Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.Operator -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.InfixApplicationExpression -infixApplicationExpression lhs operator rhs = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.InfixApplicationExpression"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "lhs"), - Core.fieldTerm = (Phantoms.unTTerm lhs)}, - Core.Field { - Core.fieldName = (Core.Name "operator"), - Core.fieldTerm = (Phantoms.unTTerm operator)}, - Core.Field { - Core.fieldName = (Core.Name "rhs"), - Core.fieldTerm = (Phantoms.unTTerm rhs)}]})) - -infixApplicationExpressionLhs :: Phantoms.TTerm Syntax.InfixApplicationExpression -> Phantoms.TTerm Syntax.Expression -infixApplicationExpressionLhs x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.InfixApplicationExpression"), - Core.projectionField = (Core.Name "lhs")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -infixApplicationExpressionOperator :: Phantoms.TTerm Syntax.InfixApplicationExpression -> Phantoms.TTerm Syntax.Operator -infixApplicationExpressionOperator x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.InfixApplicationExpression"), - Core.projectionField = (Core.Name "operator")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -infixApplicationExpressionRhs :: Phantoms.TTerm Syntax.InfixApplicationExpression -> Phantoms.TTerm Syntax.Expression -infixApplicationExpressionRhs x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.InfixApplicationExpression"), - Core.projectionField = (Core.Name "rhs")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -infixApplicationExpressionWithLhs :: Phantoms.TTerm Syntax.InfixApplicationExpression -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.InfixApplicationExpression -infixApplicationExpressionWithLhs original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.InfixApplicationExpression"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "lhs"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "operator"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.InfixApplicationExpression"), - Core.projectionField = (Core.Name "operator")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "rhs"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.InfixApplicationExpression"), - Core.projectionField = (Core.Name "rhs")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -infixApplicationExpressionWithOperator :: Phantoms.TTerm Syntax.InfixApplicationExpression -> Phantoms.TTerm Syntax.Operator -> Phantoms.TTerm Syntax.InfixApplicationExpression -infixApplicationExpressionWithOperator original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.InfixApplicationExpression"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "lhs"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.InfixApplicationExpression"), - Core.projectionField = (Core.Name "lhs")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "operator"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "rhs"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.InfixApplicationExpression"), - Core.projectionField = (Core.Name "rhs")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -infixApplicationExpressionWithRhs :: Phantoms.TTerm Syntax.InfixApplicationExpression -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.InfixApplicationExpression -infixApplicationExpressionWithRhs original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.InfixApplicationExpression"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "lhs"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.InfixApplicationExpression"), - Core.projectionField = (Core.Name "lhs")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "operator"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.InfixApplicationExpression"), - Core.projectionField = (Core.Name "operator")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "rhs"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -infixType :: Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.Operator -> Phantoms.TTerm Syntax.Operator -> Phantoms.TTerm Syntax.InfixType -infixType lhs operator rhs = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.InfixType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "lhs"), - Core.fieldTerm = (Phantoms.unTTerm lhs)}, - Core.Field { - Core.fieldName = (Core.Name "operator"), - Core.fieldTerm = (Phantoms.unTTerm operator)}, - Core.Field { - Core.fieldName = (Core.Name "rhs"), - Core.fieldTerm = (Phantoms.unTTerm rhs)}]})) - -infixTypeLhs :: Phantoms.TTerm Syntax.InfixType -> Phantoms.TTerm Syntax.Type -infixTypeLhs x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.InfixType"), - Core.projectionField = (Core.Name "lhs")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -infixTypeOperator :: Phantoms.TTerm Syntax.InfixType -> Phantoms.TTerm Syntax.Operator -infixTypeOperator x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.InfixType"), - Core.projectionField = (Core.Name "operator")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -infixTypeRhs :: Phantoms.TTerm Syntax.InfixType -> Phantoms.TTerm Syntax.Operator -infixTypeRhs x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.InfixType"), - Core.projectionField = (Core.Name "rhs")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -infixTypeWithLhs :: Phantoms.TTerm Syntax.InfixType -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.InfixType -infixTypeWithLhs original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.InfixType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "lhs"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "operator"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.InfixType"), - Core.projectionField = (Core.Name "operator")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "rhs"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.InfixType"), - Core.projectionField = (Core.Name "rhs")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -infixTypeWithOperator :: Phantoms.TTerm Syntax.InfixType -> Phantoms.TTerm Syntax.Operator -> Phantoms.TTerm Syntax.InfixType -infixTypeWithOperator original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.InfixType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "lhs"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.InfixType"), - Core.projectionField = (Core.Name "lhs")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "operator"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "rhs"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.InfixType"), - Core.projectionField = (Core.Name "rhs")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -infixTypeWithRhs :: Phantoms.TTerm Syntax.InfixType -> Phantoms.TTerm Syntax.Operator -> Phantoms.TTerm Syntax.InfixType -infixTypeWithRhs original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.InfixType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "lhs"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.InfixType"), - Core.projectionField = (Core.Name "lhs")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "operator"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.InfixType"), - Core.projectionField = (Core.Name "operator")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "rhs"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -lambdaExpression :: Phantoms.TTerm [Syntax.Pattern] -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.LambdaExpression -lambdaExpression bindings inner = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.LambdaExpression"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "bindings"), - Core.fieldTerm = (Phantoms.unTTerm bindings)}, - Core.Field { - Core.fieldName = (Core.Name "inner"), - Core.fieldTerm = (Phantoms.unTTerm inner)}]})) - -lambdaExpressionBindings :: Phantoms.TTerm Syntax.LambdaExpression -> Phantoms.TTerm [Syntax.Pattern] -lambdaExpressionBindings x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.LambdaExpression"), - Core.projectionField = (Core.Name "bindings")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -lambdaExpressionInner :: Phantoms.TTerm Syntax.LambdaExpression -> Phantoms.TTerm Syntax.Expression -lambdaExpressionInner x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.LambdaExpression"), - Core.projectionField = (Core.Name "inner")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -lambdaExpressionWithBindings :: Phantoms.TTerm Syntax.LambdaExpression -> Phantoms.TTerm [Syntax.Pattern] -> Phantoms.TTerm Syntax.LambdaExpression -lambdaExpressionWithBindings original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.LambdaExpression"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "bindings"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "inner"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.LambdaExpression"), - Core.projectionField = (Core.Name "inner")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -lambdaExpressionWithInner :: Phantoms.TTerm Syntax.LambdaExpression -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.LambdaExpression -lambdaExpressionWithInner original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.LambdaExpression"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "bindings"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.LambdaExpression"), - Core.projectionField = (Core.Name "bindings")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "inner"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -letExpression :: Phantoms.TTerm [Syntax.LocalBinding] -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.LetExpression -letExpression bindings inner = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.LetExpression"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "bindings"), - Core.fieldTerm = (Phantoms.unTTerm bindings)}, - Core.Field { - Core.fieldName = (Core.Name "inner"), - Core.fieldTerm = (Phantoms.unTTerm inner)}]})) - -letExpressionBindings :: Phantoms.TTerm Syntax.LetExpression -> Phantoms.TTerm [Syntax.LocalBinding] -letExpressionBindings x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.LetExpression"), - Core.projectionField = (Core.Name "bindings")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -letExpressionInner :: Phantoms.TTerm Syntax.LetExpression -> Phantoms.TTerm Syntax.Expression -letExpressionInner x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.LetExpression"), - Core.projectionField = (Core.Name "inner")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -letExpressionWithBindings :: Phantoms.TTerm Syntax.LetExpression -> Phantoms.TTerm [Syntax.LocalBinding] -> Phantoms.TTerm Syntax.LetExpression -letExpressionWithBindings original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.LetExpression"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "bindings"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "inner"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.LetExpression"), - Core.projectionField = (Core.Name "inner")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -letExpressionWithInner :: Phantoms.TTerm Syntax.LetExpression -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.LetExpression -letExpressionWithInner original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.LetExpression"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "bindings"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.LetExpression"), - Core.projectionField = (Core.Name "bindings")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "inner"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -literalChar :: Phantoms.TTerm Int -> Phantoms.TTerm Syntax.Literal -literalChar x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "char"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -literalDouble :: Phantoms.TTerm Double -> Phantoms.TTerm Syntax.Literal -literalDouble x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "double"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -literalFloat :: Phantoms.TTerm Float -> Phantoms.TTerm Syntax.Literal -literalFloat x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "float"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -literalInt :: Phantoms.TTerm Int -> Phantoms.TTerm Syntax.Literal -literalInt x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -literalInteger :: Phantoms.TTerm Integer -> Phantoms.TTerm Syntax.Literal -literalInteger x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -literalString :: Phantoms.TTerm String -> Phantoms.TTerm Syntax.Literal -literalString x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -localBindingSignature :: Phantoms.TTerm Syntax.TypeSignature -> Phantoms.TTerm Syntax.LocalBinding -localBindingSignature x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.LocalBinding"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "signature"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -localBindingValue :: Phantoms.TTerm Syntax.ValueBinding -> Phantoms.TTerm Syntax.LocalBinding -localBindingValue x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.LocalBinding"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "value"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -localBindings :: Phantoms.TTerm [Syntax.LocalBinding] -> Phantoms.TTerm Syntax.LocalBindings -localBindings x = - Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.ext.haskell.syntax.LocalBindings"), - Core.wrappedTermBody = (Phantoms.unTTerm x)})) - -module_ :: Phantoms.TTerm (Maybe Syntax.ModuleHead) -> Phantoms.TTerm [Syntax.Import] -> Phantoms.TTerm [Syntax.DeclarationWithComments] -> Phantoms.TTerm Syntax.Module -module_ head imports declarations = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.Module"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "head"), - Core.fieldTerm = (Phantoms.unTTerm head)}, - Core.Field { - Core.fieldName = (Core.Name "imports"), - Core.fieldTerm = (Phantoms.unTTerm imports)}, - Core.Field { - Core.fieldName = (Core.Name "declarations"), - Core.fieldTerm = (Phantoms.unTTerm declarations)}]})) - -moduleDeclarations :: Phantoms.TTerm Syntax.Module -> Phantoms.TTerm [Syntax.DeclarationWithComments] -moduleDeclarations x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Module"), - Core.projectionField = (Core.Name "declarations")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -moduleHead :: Phantoms.TTerm Syntax.Module -> Phantoms.TTerm (Maybe Syntax.ModuleHead) -moduleHead x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Module"), - Core.projectionField = (Core.Name "head")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -moduleHeadComments :: Phantoms.TTerm Syntax.ModuleHead -> Phantoms.TTerm (Maybe String) -moduleHeadComments x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.ModuleHead"), - Core.projectionField = (Core.Name "comments")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -moduleHeadExports :: Phantoms.TTerm Syntax.ModuleHead -> Phantoms.TTerm [Syntax.Export] -moduleHeadExports x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.ModuleHead"), - Core.projectionField = (Core.Name "exports")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -moduleHeadName :: Phantoms.TTerm Syntax.ModuleHead -> Phantoms.TTerm Syntax.ModuleName -moduleHeadName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.ModuleHead"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -moduleHeadWithComments :: Phantoms.TTerm Syntax.ModuleHead -> Phantoms.TTerm (Maybe String) -> Phantoms.TTerm Syntax.ModuleHead -moduleHeadWithComments original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.ModuleHead"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "comments"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.ModuleHead"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "exports"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.ModuleHead"), - Core.projectionField = (Core.Name "exports")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -moduleHeadWithExports :: Phantoms.TTerm Syntax.ModuleHead -> Phantoms.TTerm [Syntax.Export] -> Phantoms.TTerm Syntax.ModuleHead -moduleHeadWithExports original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.ModuleHead"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "comments"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.ModuleHead"), - Core.projectionField = (Core.Name "comments")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.ModuleHead"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "exports"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -moduleHeadWithName :: Phantoms.TTerm Syntax.ModuleHead -> Phantoms.TTerm Syntax.ModuleName -> Phantoms.TTerm Syntax.ModuleHead -moduleHeadWithName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.ModuleHead"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "comments"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.ModuleHead"), - Core.projectionField = (Core.Name "comments")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "exports"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.ModuleHead"), - Core.projectionField = (Core.Name "exports")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -moduleHead_ :: Phantoms.TTerm (Maybe String) -> Phantoms.TTerm Syntax.ModuleName -> Phantoms.TTerm [Syntax.Export] -> Phantoms.TTerm Syntax.ModuleHead -moduleHead_ comments name exports = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.ModuleHead"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "comments"), - Core.fieldTerm = (Phantoms.unTTerm comments)}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm name)}, - Core.Field { - Core.fieldName = (Core.Name "exports"), - Core.fieldTerm = (Phantoms.unTTerm exports)}]})) - -moduleImports :: Phantoms.TTerm Syntax.Module -> Phantoms.TTerm [Syntax.Import] -moduleImports x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Module"), - Core.projectionField = (Core.Name "imports")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -moduleName :: Phantoms.TTerm String -> Phantoms.TTerm Syntax.ModuleName -moduleName x = - Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.ext.haskell.syntax.ModuleName"), - Core.wrappedTermBody = (Phantoms.unTTerm x)})) - -moduleWithDeclarations :: Phantoms.TTerm Syntax.Module -> Phantoms.TTerm [Syntax.DeclarationWithComments] -> Phantoms.TTerm Syntax.Module -moduleWithDeclarations original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.Module"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "head"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Module"), - Core.projectionField = (Core.Name "head")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "imports"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Module"), - Core.projectionField = (Core.Name "imports")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "declarations"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -moduleWithHead :: Phantoms.TTerm Syntax.Module -> Phantoms.TTerm (Maybe Syntax.ModuleHead) -> Phantoms.TTerm Syntax.Module -moduleWithHead original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.Module"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "head"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "imports"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Module"), - Core.projectionField = (Core.Name "imports")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "declarations"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Module"), - Core.projectionField = (Core.Name "declarations")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -moduleWithImports :: Phantoms.TTerm Syntax.Module -> Phantoms.TTerm [Syntax.Import] -> Phantoms.TTerm Syntax.Module -moduleWithImports original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.Module"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "head"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Module"), - Core.projectionField = (Core.Name "head")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "imports"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "declarations"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Module"), - Core.projectionField = (Core.Name "declarations")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -nameImplicit :: Phantoms.TTerm Syntax.QualifiedName -> Phantoms.TTerm Syntax.Name -nameImplicit x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Name"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "implicit"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -nameNormal :: Phantoms.TTerm Syntax.QualifiedName -> Phantoms.TTerm Syntax.Name -nameNormal x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Name"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "normal"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -nameParens :: Phantoms.TTerm Syntax.QualifiedName -> Phantoms.TTerm Syntax.Name -nameParens x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Name"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "parens"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -namePart :: Phantoms.TTerm String -> Phantoms.TTerm Syntax.NamePart -namePart x = - Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.ext.haskell.syntax.NamePart"), - Core.wrappedTermBody = (Phantoms.unTTerm x)})) - -operatorBacktick :: Phantoms.TTerm Syntax.QualifiedName -> Phantoms.TTerm Syntax.Operator -operatorBacktick x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Operator"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "backtick"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -operatorNormal :: Phantoms.TTerm Syntax.QualifiedName -> Phantoms.TTerm Syntax.Operator -operatorNormal x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Operator"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "normal"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -ordinaryConstructor :: Phantoms.TTerm Syntax.Name -> Phantoms.TTerm [Syntax.Type] -> Phantoms.TTerm Syntax.OrdinaryConstructor -ordinaryConstructor name fields = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.OrdinaryConstructor"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm name)}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Phantoms.unTTerm fields)}]})) - -ordinaryConstructorFields :: Phantoms.TTerm Syntax.OrdinaryConstructor -> Phantoms.TTerm [Syntax.Type] -ordinaryConstructorFields x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.OrdinaryConstructor"), - Core.projectionField = (Core.Name "fields")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -ordinaryConstructorName :: Phantoms.TTerm Syntax.OrdinaryConstructor -> Phantoms.TTerm Syntax.Name -ordinaryConstructorName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.OrdinaryConstructor"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -ordinaryConstructorWithFields :: Phantoms.TTerm Syntax.OrdinaryConstructor -> Phantoms.TTerm [Syntax.Type] -> Phantoms.TTerm Syntax.OrdinaryConstructor -ordinaryConstructorWithFields original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.OrdinaryConstructor"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.OrdinaryConstructor"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -ordinaryConstructorWithName :: Phantoms.TTerm Syntax.OrdinaryConstructor -> Phantoms.TTerm Syntax.Name -> Phantoms.TTerm Syntax.OrdinaryConstructor -ordinaryConstructorWithName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.OrdinaryConstructor"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.OrdinaryConstructor"), - Core.projectionField = (Core.Name "fields")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -patternApplication :: Phantoms.TTerm Syntax.ApplicationPattern -> Phantoms.TTerm Syntax.Pattern -patternApplication x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Pattern"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "application"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -patternAs :: Phantoms.TTerm Syntax.AsPattern -> Phantoms.TTerm Syntax.Pattern -patternAs x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Pattern"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "as"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -patternField :: Phantoms.TTerm Syntax.Name -> Phantoms.TTerm Syntax.Pattern -> Phantoms.TTerm Syntax.PatternField -patternField name pattern = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.PatternField"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm name)}, - Core.Field { - Core.fieldName = (Core.Name "pattern"), - Core.fieldTerm = (Phantoms.unTTerm pattern)}]})) - -patternFieldName :: Phantoms.TTerm Syntax.PatternField -> Phantoms.TTerm Syntax.Name -patternFieldName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.PatternField"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -patternFieldPattern :: Phantoms.TTerm Syntax.PatternField -> Phantoms.TTerm Syntax.Pattern -patternFieldPattern x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.PatternField"), - Core.projectionField = (Core.Name "pattern")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -patternFieldWithName :: Phantoms.TTerm Syntax.PatternField -> Phantoms.TTerm Syntax.Name -> Phantoms.TTerm Syntax.PatternField -patternFieldWithName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.PatternField"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "pattern"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.PatternField"), - Core.projectionField = (Core.Name "pattern")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -patternFieldWithPattern :: Phantoms.TTerm Syntax.PatternField -> Phantoms.TTerm Syntax.Pattern -> Phantoms.TTerm Syntax.PatternField -patternFieldWithPattern original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.PatternField"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.PatternField"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "pattern"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -patternList :: Phantoms.TTerm [Syntax.Pattern] -> Phantoms.TTerm Syntax.Pattern -patternList x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Pattern"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -patternLiteral :: Phantoms.TTerm Syntax.Literal -> Phantoms.TTerm Syntax.Pattern -patternLiteral x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Pattern"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -patternName :: Phantoms.TTerm Syntax.Name -> Phantoms.TTerm Syntax.Pattern -patternName x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Pattern"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -patternParens :: Phantoms.TTerm Syntax.Pattern -> Phantoms.TTerm Syntax.Pattern -patternParens x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Pattern"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "parens"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -patternRecord :: Phantoms.TTerm Syntax.RecordPattern -> Phantoms.TTerm Syntax.Pattern -patternRecord x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Pattern"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -patternTuple :: Phantoms.TTerm [Syntax.Pattern] -> Phantoms.TTerm Syntax.Pattern -patternTuple x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Pattern"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "tuple"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -patternTyped :: Phantoms.TTerm Syntax.TypedPattern -> Phantoms.TTerm Syntax.Pattern -patternTyped x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Pattern"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "typed"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -patternWildcard :: Phantoms.TTerm Syntax.Pattern -patternWildcard = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Pattern"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wildcard"), - Core.fieldTerm = Core.TermUnit}})) - -prefixApplicationExpression :: Phantoms.TTerm Syntax.Operator -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.PrefixApplicationExpression -prefixApplicationExpression operator rhs = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.PrefixApplicationExpression"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "operator"), - Core.fieldTerm = (Phantoms.unTTerm operator)}, - Core.Field { - Core.fieldName = (Core.Name "rhs"), - Core.fieldTerm = (Phantoms.unTTerm rhs)}]})) - -prefixApplicationExpressionOperator :: Phantoms.TTerm Syntax.PrefixApplicationExpression -> Phantoms.TTerm Syntax.Operator -prefixApplicationExpressionOperator x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.PrefixApplicationExpression"), - Core.projectionField = (Core.Name "operator")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -prefixApplicationExpressionRhs :: Phantoms.TTerm Syntax.PrefixApplicationExpression -> Phantoms.TTerm Syntax.Expression -prefixApplicationExpressionRhs x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.PrefixApplicationExpression"), - Core.projectionField = (Core.Name "rhs")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -prefixApplicationExpressionWithOperator :: Phantoms.TTerm Syntax.PrefixApplicationExpression -> Phantoms.TTerm Syntax.Operator -> Phantoms.TTerm Syntax.PrefixApplicationExpression -prefixApplicationExpressionWithOperator original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.PrefixApplicationExpression"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "operator"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "rhs"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.PrefixApplicationExpression"), - Core.projectionField = (Core.Name "rhs")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -prefixApplicationExpressionWithRhs :: Phantoms.TTerm Syntax.PrefixApplicationExpression -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.PrefixApplicationExpression -prefixApplicationExpressionWithRhs original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.PrefixApplicationExpression"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "operator"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.PrefixApplicationExpression"), - Core.projectionField = (Core.Name "operator")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "rhs"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -qualifiedName :: Phantoms.TTerm [Syntax.NamePart] -> Phantoms.TTerm Syntax.NamePart -> Phantoms.TTerm Syntax.QualifiedName -qualifiedName qualifiers unqualified = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.QualifiedName"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "qualifiers"), - Core.fieldTerm = (Phantoms.unTTerm qualifiers)}, - Core.Field { - Core.fieldName = (Core.Name "unqualified"), - Core.fieldTerm = (Phantoms.unTTerm unqualified)}]})) - -qualifiedNameQualifiers :: Phantoms.TTerm Syntax.QualifiedName -> Phantoms.TTerm [Syntax.NamePart] -qualifiedNameQualifiers x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.QualifiedName"), - Core.projectionField = (Core.Name "qualifiers")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -qualifiedNameUnqualified :: Phantoms.TTerm Syntax.QualifiedName -> Phantoms.TTerm Syntax.NamePart -qualifiedNameUnqualified x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.QualifiedName"), - Core.projectionField = (Core.Name "unqualified")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -qualifiedNameWithQualifiers :: Phantoms.TTerm Syntax.QualifiedName -> Phantoms.TTerm [Syntax.NamePart] -> Phantoms.TTerm Syntax.QualifiedName -qualifiedNameWithQualifiers original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.QualifiedName"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "qualifiers"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "unqualified"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.QualifiedName"), - Core.projectionField = (Core.Name "unqualified")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -qualifiedNameWithUnqualified :: Phantoms.TTerm Syntax.QualifiedName -> Phantoms.TTerm Syntax.NamePart -> Phantoms.TTerm Syntax.QualifiedName -qualifiedNameWithUnqualified original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.QualifiedName"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "qualifiers"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.QualifiedName"), - Core.projectionField = (Core.Name "qualifiers")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "unqualified"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -recordConstructor :: Phantoms.TTerm Syntax.Name -> Phantoms.TTerm [Syntax.FieldWithComments] -> Phantoms.TTerm Syntax.RecordConstructor -recordConstructor name fields = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.RecordConstructor"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm name)}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Phantoms.unTTerm fields)}]})) - -recordConstructorFields :: Phantoms.TTerm Syntax.RecordConstructor -> Phantoms.TTerm [Syntax.FieldWithComments] -recordConstructorFields x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.RecordConstructor"), - Core.projectionField = (Core.Name "fields")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -recordConstructorName :: Phantoms.TTerm Syntax.RecordConstructor -> Phantoms.TTerm Syntax.Name -recordConstructorName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.RecordConstructor"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -recordConstructorWithFields :: Phantoms.TTerm Syntax.RecordConstructor -> Phantoms.TTerm [Syntax.FieldWithComments] -> Phantoms.TTerm Syntax.RecordConstructor -recordConstructorWithFields original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.RecordConstructor"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.RecordConstructor"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -recordConstructorWithName :: Phantoms.TTerm Syntax.RecordConstructor -> Phantoms.TTerm Syntax.Name -> Phantoms.TTerm Syntax.RecordConstructor -recordConstructorWithName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.RecordConstructor"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.RecordConstructor"), - Core.projectionField = (Core.Name "fields")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -recordPattern :: Phantoms.TTerm Syntax.Name -> Phantoms.TTerm [Syntax.PatternField] -> Phantoms.TTerm Syntax.RecordPattern -recordPattern name fields = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.RecordPattern"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm name)}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Phantoms.unTTerm fields)}]})) - -recordPatternFields :: Phantoms.TTerm Syntax.RecordPattern -> Phantoms.TTerm [Syntax.PatternField] -recordPatternFields x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.RecordPattern"), - Core.projectionField = (Core.Name "fields")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -recordPatternName :: Phantoms.TTerm Syntax.RecordPattern -> Phantoms.TTerm Syntax.Name -recordPatternName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.RecordPattern"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -recordPatternWithFields :: Phantoms.TTerm Syntax.RecordPattern -> Phantoms.TTerm [Syntax.PatternField] -> Phantoms.TTerm Syntax.RecordPattern -recordPatternWithFields original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.RecordPattern"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.RecordPattern"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -recordPatternWithName :: Phantoms.TTerm Syntax.RecordPattern -> Phantoms.TTerm Syntax.Name -> Phantoms.TTerm Syntax.RecordPattern -recordPatternWithName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.RecordPattern"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.RecordPattern"), - Core.projectionField = (Core.Name "fields")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -rightHandSide :: Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.RightHandSide -rightHandSide x = - Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.ext.haskell.syntax.RightHandSide"), - Core.wrappedTermBody = (Phantoms.unTTerm x)})) - -sectionExpression :: Phantoms.TTerm Syntax.Operator -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.SectionExpression -sectionExpression operator expression = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.SectionExpression"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "operator"), - Core.fieldTerm = (Phantoms.unTTerm operator)}, - Core.Field { - Core.fieldName = (Core.Name "expression"), - Core.fieldTerm = (Phantoms.unTTerm expression)}]})) - -sectionExpressionExpression :: Phantoms.TTerm Syntax.SectionExpression -> Phantoms.TTerm Syntax.Expression -sectionExpressionExpression x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.SectionExpression"), - Core.projectionField = (Core.Name "expression")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -sectionExpressionOperator :: Phantoms.TTerm Syntax.SectionExpression -> Phantoms.TTerm Syntax.Operator -sectionExpressionOperator x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.SectionExpression"), - Core.projectionField = (Core.Name "operator")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -sectionExpressionWithExpression :: Phantoms.TTerm Syntax.SectionExpression -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.SectionExpression -sectionExpressionWithExpression original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.SectionExpression"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "operator"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.SectionExpression"), - Core.projectionField = (Core.Name "operator")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "expression"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -sectionExpressionWithOperator :: Phantoms.TTerm Syntax.SectionExpression -> Phantoms.TTerm Syntax.Operator -> Phantoms.TTerm Syntax.SectionExpression -sectionExpressionWithOperator original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.SectionExpression"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "operator"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "expression"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.SectionExpression"), - Core.projectionField = (Core.Name "expression")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -simpleValueBinding :: Phantoms.TTerm Syntax.Pattern -> Phantoms.TTerm Syntax.RightHandSide -> Phantoms.TTerm (Maybe Syntax.LocalBindings) -> Phantoms.TTerm Syntax.SimpleValueBinding -simpleValueBinding pattern rhs localBindings = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.SimpleValueBinding"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "pattern"), - Core.fieldTerm = (Phantoms.unTTerm pattern)}, - Core.Field { - Core.fieldName = (Core.Name "rhs"), - Core.fieldTerm = (Phantoms.unTTerm rhs)}, - Core.Field { - Core.fieldName = (Core.Name "localBindings"), - Core.fieldTerm = (Phantoms.unTTerm localBindings)}]})) - -simpleValueBindingLocalBindings :: Phantoms.TTerm Syntax.SimpleValueBinding -> Phantoms.TTerm (Maybe Syntax.LocalBindings) -simpleValueBindingLocalBindings x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.SimpleValueBinding"), - Core.projectionField = (Core.Name "localBindings")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -simpleValueBindingPattern :: Phantoms.TTerm Syntax.SimpleValueBinding -> Phantoms.TTerm Syntax.Pattern -simpleValueBindingPattern x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.SimpleValueBinding"), - Core.projectionField = (Core.Name "pattern")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -simpleValueBindingRhs :: Phantoms.TTerm Syntax.SimpleValueBinding -> Phantoms.TTerm Syntax.RightHandSide -simpleValueBindingRhs x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.SimpleValueBinding"), - Core.projectionField = (Core.Name "rhs")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -simpleValueBindingWithLocalBindings :: Phantoms.TTerm Syntax.SimpleValueBinding -> Phantoms.TTerm (Maybe Syntax.LocalBindings) -> Phantoms.TTerm Syntax.SimpleValueBinding -simpleValueBindingWithLocalBindings original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.SimpleValueBinding"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "pattern"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.SimpleValueBinding"), - Core.projectionField = (Core.Name "pattern")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "rhs"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.SimpleValueBinding"), - Core.projectionField = (Core.Name "rhs")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "localBindings"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -simpleValueBindingWithPattern :: Phantoms.TTerm Syntax.SimpleValueBinding -> Phantoms.TTerm Syntax.Pattern -> Phantoms.TTerm Syntax.SimpleValueBinding -simpleValueBindingWithPattern original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.SimpleValueBinding"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "pattern"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "rhs"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.SimpleValueBinding"), - Core.projectionField = (Core.Name "rhs")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "localBindings"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.SimpleValueBinding"), - Core.projectionField = (Core.Name "localBindings")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -simpleValueBindingWithRhs :: Phantoms.TTerm Syntax.SimpleValueBinding -> Phantoms.TTerm Syntax.RightHandSide -> Phantoms.TTerm Syntax.SimpleValueBinding -simpleValueBindingWithRhs original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.SimpleValueBinding"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "pattern"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.SimpleValueBinding"), - Core.projectionField = (Core.Name "pattern")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "rhs"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "localBindings"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.SimpleValueBinding"), - Core.projectionField = (Core.Name "localBindings")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -specImportHiding :: Phantoms.TTerm [Syntax.ImportExportSpec] -> Phantoms.TTerm Syntax.SpecImport -specImportHiding x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.SpecImport"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "hiding"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -specImportList :: Phantoms.TTerm [Syntax.ImportExportSpec] -> Phantoms.TTerm Syntax.SpecImport -specImportList x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.SpecImport"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -statement :: Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.Statement -statement x = - Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.ext.haskell.syntax.Statement"), - Core.wrappedTermBody = (Phantoms.unTTerm x)})) - -subspecImportExportSpecAll :: Phantoms.TTerm Syntax.SubspecImportExportSpec -subspecImportExportSpecAll = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.SubspecImportExportSpec"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "all"), - Core.fieldTerm = Core.TermUnit}})) - -subspecImportExportSpecList :: Phantoms.TTerm [Syntax.Name] -> Phantoms.TTerm Syntax.SubspecImportExportSpec -subspecImportExportSpecList x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.SubspecImportExportSpec"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -typeApplication :: Phantoms.TTerm Syntax.ApplicationType -> Phantoms.TTerm Syntax.Type -typeApplication x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "application"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -typeCtx :: Phantoms.TTerm Syntax.ContextType -> Phantoms.TTerm Syntax.Type -typeCtx x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "ctx"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -typeDeclaration :: Phantoms.TTerm Syntax.DeclarationHead -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.TypeDeclaration -typeDeclaration name type_ = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.TypeDeclaration"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm name)}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Phantoms.unTTerm type_)}]})) - -typeDeclarationName :: Phantoms.TTerm Syntax.TypeDeclaration -> Phantoms.TTerm Syntax.DeclarationHead -typeDeclarationName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.TypeDeclaration"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -typeDeclarationType :: Phantoms.TTerm Syntax.TypeDeclaration -> Phantoms.TTerm Syntax.Type -typeDeclarationType x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.TypeDeclaration"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -typeDeclarationWithName :: Phantoms.TTerm Syntax.TypeDeclaration -> Phantoms.TTerm Syntax.DeclarationHead -> Phantoms.TTerm Syntax.TypeDeclaration -typeDeclarationWithName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.TypeDeclaration"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.TypeDeclaration"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -typeDeclarationWithType :: Phantoms.TTerm Syntax.TypeDeclaration -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.TypeDeclaration -typeDeclarationWithType original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.TypeDeclaration"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.TypeDeclaration"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -typeFunction :: Phantoms.TTerm Syntax.FunctionType -> Phantoms.TTerm Syntax.Type -typeFunction x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "function"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -typeInfix :: Phantoms.TTerm Syntax.InfixType -> Phantoms.TTerm Syntax.Type -typeInfix x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "infix"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -typeList :: Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.Type -typeList x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -typeParens :: Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.Type -typeParens x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "parens"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -typeSignature :: Phantoms.TTerm Syntax.Name -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.TypeSignature -typeSignature name type_ = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.TypeSignature"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm name)}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Phantoms.unTTerm type_)}]})) - -typeSignatureExpression :: Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.TypeSignatureExpression -typeSignatureExpression inner type_ = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.TypeSignatureExpression"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "inner"), - Core.fieldTerm = (Phantoms.unTTerm inner)}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Phantoms.unTTerm type_)}]})) - -typeSignatureExpressionInner :: Phantoms.TTerm Syntax.TypeSignatureExpression -> Phantoms.TTerm Syntax.Expression -typeSignatureExpressionInner x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.TypeSignatureExpression"), - Core.projectionField = (Core.Name "inner")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -typeSignatureExpressionType :: Phantoms.TTerm Syntax.TypeSignatureExpression -> Phantoms.TTerm Syntax.Type -typeSignatureExpressionType x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.TypeSignatureExpression"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -typeSignatureExpressionWithInner :: Phantoms.TTerm Syntax.TypeSignatureExpression -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.TypeSignatureExpression -typeSignatureExpressionWithInner original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.TypeSignatureExpression"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "inner"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.TypeSignatureExpression"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -typeSignatureExpressionWithType :: Phantoms.TTerm Syntax.TypeSignatureExpression -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.TypeSignatureExpression -typeSignatureExpressionWithType original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.TypeSignatureExpression"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "inner"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.TypeSignatureExpression"), - Core.projectionField = (Core.Name "inner")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -typeSignatureName :: Phantoms.TTerm Syntax.TypeSignature -> Phantoms.TTerm Syntax.Name -typeSignatureName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.TypeSignature"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -typeSignatureType :: Phantoms.TTerm Syntax.TypeSignature -> Phantoms.TTerm Syntax.Type -typeSignatureType x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.TypeSignature"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -typeSignatureWithName :: Phantoms.TTerm Syntax.TypeSignature -> Phantoms.TTerm Syntax.Name -> Phantoms.TTerm Syntax.TypeSignature -typeSignatureWithName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.TypeSignature"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.TypeSignature"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -typeSignatureWithType :: Phantoms.TTerm Syntax.TypeSignature -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.TypeSignature -typeSignatureWithType original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.TypeSignature"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.TypeSignature"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -typeTuple :: Phantoms.TTerm [Syntax.Type] -> Phantoms.TTerm Syntax.Type -typeTuple x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "tuple"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -typeVariable :: Phantoms.TTerm Syntax.Name -> Phantoms.TTerm Syntax.Type -typeVariable x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "variable"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -typedBinding :: Phantoms.TTerm Syntax.TypeSignature -> Phantoms.TTerm Syntax.ValueBinding -> Phantoms.TTerm Syntax.TypedBinding -typedBinding typeSignature valueBinding = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.TypedBinding"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeSignature"), - Core.fieldTerm = (Phantoms.unTTerm typeSignature)}, - Core.Field { - Core.fieldName = (Core.Name "valueBinding"), - Core.fieldTerm = (Phantoms.unTTerm valueBinding)}]})) - -typedBindingTypeSignature :: Phantoms.TTerm Syntax.TypedBinding -> Phantoms.TTerm Syntax.TypeSignature -typedBindingTypeSignature x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.TypedBinding"), - Core.projectionField = (Core.Name "typeSignature")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -typedBindingValueBinding :: Phantoms.TTerm Syntax.TypedBinding -> Phantoms.TTerm Syntax.ValueBinding -typedBindingValueBinding x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.TypedBinding"), - Core.projectionField = (Core.Name "valueBinding")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -typedBindingWithTypeSignature :: Phantoms.TTerm Syntax.TypedBinding -> Phantoms.TTerm Syntax.TypeSignature -> Phantoms.TTerm Syntax.TypedBinding -typedBindingWithTypeSignature original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.TypedBinding"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeSignature"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "valueBinding"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.TypedBinding"), - Core.projectionField = (Core.Name "valueBinding")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -typedBindingWithValueBinding :: Phantoms.TTerm Syntax.TypedBinding -> Phantoms.TTerm Syntax.ValueBinding -> Phantoms.TTerm Syntax.TypedBinding -typedBindingWithValueBinding original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.TypedBinding"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeSignature"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.TypedBinding"), - Core.projectionField = (Core.Name "typeSignature")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "valueBinding"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -typedPattern :: Phantoms.TTerm Syntax.Pattern -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.TypedPattern -typedPattern inner type_ = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.TypedPattern"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "inner"), - Core.fieldTerm = (Phantoms.unTTerm inner)}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Phantoms.unTTerm type_)}]})) - -typedPatternInner :: Phantoms.TTerm Syntax.TypedPattern -> Phantoms.TTerm Syntax.Pattern -typedPatternInner x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.TypedPattern"), - Core.projectionField = (Core.Name "inner")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -typedPatternType :: Phantoms.TTerm Syntax.TypedPattern -> Phantoms.TTerm Syntax.Type -typedPatternType x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.TypedPattern"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -typedPatternWithInner :: Phantoms.TTerm Syntax.TypedPattern -> Phantoms.TTerm Syntax.Pattern -> Phantoms.TTerm Syntax.TypedPattern -typedPatternWithInner original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.TypedPattern"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "inner"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.TypedPattern"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -typedPatternWithType :: Phantoms.TTerm Syntax.TypedPattern -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.TypedPattern -typedPatternWithType original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.TypedPattern"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "inner"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.TypedPattern"), - Core.projectionField = (Core.Name "inner")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -unCaseRhs :: Phantoms.TTerm Syntax.CaseRhs -> Phantoms.TTerm Syntax.Expression -unCaseRhs x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.ext.haskell.syntax.CaseRhs")))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -unDeriving :: Phantoms.TTerm Syntax.Deriving -> Phantoms.TTerm [Syntax.Name] -unDeriving x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.ext.haskell.syntax.Deriving")))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -unLocalBindings :: Phantoms.TTerm Syntax.LocalBindings -> Phantoms.TTerm [Syntax.LocalBinding] -unLocalBindings x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.ext.haskell.syntax.LocalBindings")))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -unModuleName :: Phantoms.TTerm Syntax.ModuleName -> Phantoms.TTerm String -unModuleName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.ext.haskell.syntax.ModuleName")))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -unNamePart :: Phantoms.TTerm Syntax.NamePart -> Phantoms.TTerm String -unNamePart x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.ext.haskell.syntax.NamePart")))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -unRightHandSide :: Phantoms.TTerm Syntax.RightHandSide -> Phantoms.TTerm Syntax.Expression -unRightHandSide x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.ext.haskell.syntax.RightHandSide")))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -unStatement :: Phantoms.TTerm Syntax.Statement -> Phantoms.TTerm Syntax.Expression -unStatement x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.ext.haskell.syntax.Statement")))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -unVariable :: Phantoms.TTerm Syntax.Variable -> Phantoms.TTerm Syntax.Name -unVariable x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.ext.haskell.syntax.Variable")))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -updateRecordExpression :: Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm [Syntax.FieldUpdate] -> Phantoms.TTerm Syntax.UpdateRecordExpression -updateRecordExpression inner fields = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.UpdateRecordExpression"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "inner"), - Core.fieldTerm = (Phantoms.unTTerm inner)}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Phantoms.unTTerm fields)}]})) - -updateRecordExpressionFields :: Phantoms.TTerm Syntax.UpdateRecordExpression -> Phantoms.TTerm [Syntax.FieldUpdate] -updateRecordExpressionFields x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.UpdateRecordExpression"), - Core.projectionField = (Core.Name "fields")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -updateRecordExpressionInner :: Phantoms.TTerm Syntax.UpdateRecordExpression -> Phantoms.TTerm Syntax.Expression -updateRecordExpressionInner x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.UpdateRecordExpression"), - Core.projectionField = (Core.Name "inner")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -updateRecordExpressionWithFields :: Phantoms.TTerm Syntax.UpdateRecordExpression -> Phantoms.TTerm [Syntax.FieldUpdate] -> Phantoms.TTerm Syntax.UpdateRecordExpression -updateRecordExpressionWithFields original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.UpdateRecordExpression"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "inner"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.UpdateRecordExpression"), - Core.projectionField = (Core.Name "inner")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -updateRecordExpressionWithInner :: Phantoms.TTerm Syntax.UpdateRecordExpression -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.UpdateRecordExpression -updateRecordExpressionWithInner original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ext.haskell.syntax.UpdateRecordExpression"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "inner"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.ext.haskell.syntax.UpdateRecordExpression"), - Core.projectionField = (Core.Name "fields")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -valueBindingSimple :: Phantoms.TTerm Syntax.SimpleValueBinding -> Phantoms.TTerm Syntax.ValueBinding -valueBindingSimple x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.haskell.syntax.ValueBinding"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "simple"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -variable :: Phantoms.TTerm Syntax.Name -> Phantoms.TTerm Syntax.Variable -variable x = - Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.ext.haskell.syntax.Variable"), - Core.wrappedTermBody = (Phantoms.unTTerm x)})) diff --git a/src/gen-main/haskell/Hydra/Dsl/Ext/Org/Yaml/Model.hs b/src/gen-main/haskell/Hydra/Dsl/Ext/Org/Yaml/Model.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Dsl/Ext/Org/Yaml/Model.hs +++ /dev/null @@ -1,79 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | DSL functions for hydra.ext.org.yaml.model - -module Hydra.Dsl.Ext.Org.Yaml.Model where - -import qualified Hydra.Core as Core -import qualified Hydra.Ext.Org.Yaml.Model as Model -import qualified Hydra.Phantoms as Phantoms -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -nodeMapping :: Phantoms.TTerm (M.Map Model.Node Model.Node) -> Phantoms.TTerm Model.Node -nodeMapping x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.org.yaml.model.Node"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "mapping"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -nodeScalar :: Phantoms.TTerm Model.Scalar -> Phantoms.TTerm Model.Node -nodeScalar x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.org.yaml.model.Node"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "scalar"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -nodeSequence :: Phantoms.TTerm [Model.Node] -> Phantoms.TTerm Model.Node -nodeSequence x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.org.yaml.model.Node"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "sequence"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -scalarBool :: Phantoms.TTerm Bool -> Phantoms.TTerm Model.Scalar -scalarBool x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.org.yaml.model.Scalar"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "bool"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -scalarFloat :: Phantoms.TTerm Double -> Phantoms.TTerm Model.Scalar -scalarFloat x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.org.yaml.model.Scalar"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "float"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -scalarInt :: Phantoms.TTerm Integer -> Phantoms.TTerm Model.Scalar -scalarInt x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.org.yaml.model.Scalar"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -scalarNull :: Phantoms.TTerm Model.Scalar -scalarNull = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.org.yaml.model.Scalar"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "null"), - Core.fieldTerm = Core.TermUnit}})) - -scalarStr :: Phantoms.TTerm String -> Phantoms.TTerm Model.Scalar -scalarStr x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ext.org.yaml.model.Scalar"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "str"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) diff --git a/src/gen-main/haskell/Hydra/Dsl/Graph.hs b/src/gen-main/haskell/Hydra/Dsl/Graph.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Dsl/Graph.hs +++ /dev/null @@ -1,791 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | DSL functions for hydra.graph - -module Hydra.Dsl.Graph where - -import qualified Hydra.Context as Context -import qualified Hydra.Core as Core -import qualified Hydra.Errors as Errors -import qualified Hydra.Graph as Graph -import qualified Hydra.Phantoms as Phantoms -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -graph :: Phantoms.TTerm (M.Map Core.Name Core.Term) -> Phantoms.TTerm (M.Map Core.Name Core.TypeScheme) -> Phantoms.TTerm (M.Map Core.Name Core.TypeVariableMetadata) -> Phantoms.TTerm (S.Set Core.Name) -> Phantoms.TTerm (M.Map Core.Name Core.Term) -> Phantoms.TTerm (M.Map Core.Name Graph.Primitive) -> Phantoms.TTerm (M.Map Core.Name Core.TypeScheme) -> Phantoms.TTerm (S.Set Core.Name) -> Phantoms.TTerm Graph.Graph -graph boundTerms boundTypes classConstraints lambdaVariables metadata primitives schemaTypes typeVariables = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.graph.Graph"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "boundTerms"), - Core.fieldTerm = (Phantoms.unTTerm boundTerms)}, - Core.Field { - Core.fieldName = (Core.Name "boundTypes"), - Core.fieldTerm = (Phantoms.unTTerm boundTypes)}, - Core.Field { - Core.fieldName = (Core.Name "classConstraints"), - Core.fieldTerm = (Phantoms.unTTerm classConstraints)}, - Core.Field { - Core.fieldName = (Core.Name "lambdaVariables"), - Core.fieldTerm = (Phantoms.unTTerm lambdaVariables)}, - Core.Field { - Core.fieldName = (Core.Name "metadata"), - Core.fieldTerm = (Phantoms.unTTerm metadata)}, - Core.Field { - Core.fieldName = (Core.Name "primitives"), - Core.fieldTerm = (Phantoms.unTTerm primitives)}, - Core.Field { - Core.fieldName = (Core.Name "schemaTypes"), - Core.fieldTerm = (Phantoms.unTTerm schemaTypes)}, - Core.Field { - Core.fieldName = (Core.Name "typeVariables"), - Core.fieldTerm = (Phantoms.unTTerm typeVariables)}]})) - -graphBoundTerms :: Phantoms.TTerm Graph.Graph -> Phantoms.TTerm (M.Map Core.Name Core.Term) -graphBoundTerms x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "boundTerms")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -graphBoundTypes :: Phantoms.TTerm Graph.Graph -> Phantoms.TTerm (M.Map Core.Name Core.TypeScheme) -graphBoundTypes x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "boundTypes")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -graphClassConstraints :: Phantoms.TTerm Graph.Graph -> Phantoms.TTerm (M.Map Core.Name Core.TypeVariableMetadata) -graphClassConstraints x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "classConstraints")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -graphLambdaVariables :: Phantoms.TTerm Graph.Graph -> Phantoms.TTerm (S.Set Core.Name) -graphLambdaVariables x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "lambdaVariables")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -graphMetadata :: Phantoms.TTerm Graph.Graph -> Phantoms.TTerm (M.Map Core.Name Core.Term) -graphMetadata x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "metadata")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -graphPrimitives :: Phantoms.TTerm Graph.Graph -> Phantoms.TTerm (M.Map Core.Name Graph.Primitive) -graphPrimitives x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "primitives")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -graphSchemaTypes :: Phantoms.TTerm Graph.Graph -> Phantoms.TTerm (M.Map Core.Name Core.TypeScheme) -graphSchemaTypes x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "schemaTypes")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -graphTypeVariables :: Phantoms.TTerm Graph.Graph -> Phantoms.TTerm (S.Set Core.Name) -graphTypeVariables x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "typeVariables")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -graphWithBoundTerms :: Phantoms.TTerm Graph.Graph -> Phantoms.TTerm (M.Map Core.Name Core.Term) -> Phantoms.TTerm Graph.Graph -graphWithBoundTerms original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.graph.Graph"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "boundTerms"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "boundTypes"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "boundTypes")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "classConstraints"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "classConstraints")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "lambdaVariables"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "lambdaVariables")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "metadata"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "metadata")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "primitives"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "primitives")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "schemaTypes"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "schemaTypes")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "typeVariables"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "typeVariables")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -graphWithBoundTypes :: Phantoms.TTerm Graph.Graph -> Phantoms.TTerm (M.Map Core.Name Core.TypeScheme) -> Phantoms.TTerm Graph.Graph -graphWithBoundTypes original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.graph.Graph"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "boundTerms"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "boundTerms")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "boundTypes"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "classConstraints"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "classConstraints")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "lambdaVariables"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "lambdaVariables")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "metadata"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "metadata")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "primitives"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "primitives")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "schemaTypes"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "schemaTypes")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "typeVariables"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "typeVariables")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -graphWithClassConstraints :: Phantoms.TTerm Graph.Graph -> Phantoms.TTerm (M.Map Core.Name Core.TypeVariableMetadata) -> Phantoms.TTerm Graph.Graph -graphWithClassConstraints original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.graph.Graph"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "boundTerms"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "boundTerms")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "boundTypes"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "boundTypes")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "classConstraints"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "lambdaVariables"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "lambdaVariables")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "metadata"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "metadata")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "primitives"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "primitives")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "schemaTypes"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "schemaTypes")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "typeVariables"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "typeVariables")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -graphWithLambdaVariables :: Phantoms.TTerm Graph.Graph -> Phantoms.TTerm (S.Set Core.Name) -> Phantoms.TTerm Graph.Graph -graphWithLambdaVariables original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.graph.Graph"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "boundTerms"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "boundTerms")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "boundTypes"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "boundTypes")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "classConstraints"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "classConstraints")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "lambdaVariables"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "metadata"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "metadata")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "primitives"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "primitives")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "schemaTypes"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "schemaTypes")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "typeVariables"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "typeVariables")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -graphWithMetadata :: Phantoms.TTerm Graph.Graph -> Phantoms.TTerm (M.Map Core.Name Core.Term) -> Phantoms.TTerm Graph.Graph -graphWithMetadata original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.graph.Graph"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "boundTerms"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "boundTerms")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "boundTypes"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "boundTypes")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "classConstraints"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "classConstraints")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "lambdaVariables"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "lambdaVariables")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "metadata"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "primitives"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "primitives")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "schemaTypes"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "schemaTypes")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "typeVariables"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "typeVariables")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -graphWithPrimitives :: Phantoms.TTerm Graph.Graph -> Phantoms.TTerm (M.Map Core.Name Graph.Primitive) -> Phantoms.TTerm Graph.Graph -graphWithPrimitives original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.graph.Graph"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "boundTerms"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "boundTerms")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "boundTypes"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "boundTypes")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "classConstraints"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "classConstraints")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "lambdaVariables"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "lambdaVariables")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "metadata"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "metadata")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "primitives"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "schemaTypes"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "schemaTypes")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "typeVariables"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "typeVariables")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -graphWithSchemaTypes :: Phantoms.TTerm Graph.Graph -> Phantoms.TTerm (M.Map Core.Name Core.TypeScheme) -> Phantoms.TTerm Graph.Graph -graphWithSchemaTypes original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.graph.Graph"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "boundTerms"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "boundTerms")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "boundTypes"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "boundTypes")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "classConstraints"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "classConstraints")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "lambdaVariables"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "lambdaVariables")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "metadata"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "metadata")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "primitives"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "primitives")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "schemaTypes"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "typeVariables"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "typeVariables")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -graphWithTypeVariables :: Phantoms.TTerm Graph.Graph -> Phantoms.TTerm (S.Set Core.Name) -> Phantoms.TTerm Graph.Graph -graphWithTypeVariables original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.graph.Graph"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "boundTerms"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "boundTerms")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "boundTypes"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "boundTypes")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "classConstraints"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "classConstraints")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "lambdaVariables"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "lambdaVariables")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "metadata"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "metadata")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "primitives"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "primitives")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "schemaTypes"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Graph"), - Core.projectionField = (Core.Name "schemaTypes")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "typeVariables"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -primitive :: Phantoms.TTerm Core.Name -> Phantoms.TTerm Core.TypeScheme -> Phantoms.TTerm (Context.Context -> Graph.Graph -> [Core.Term] -> Either (Context.InContext Errors.Error) Core.Term) -> Phantoms.TTerm Graph.Primitive -primitive name type_ implementation = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.graph.Primitive"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm name)}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Phantoms.unTTerm type_)}, - Core.Field { - Core.fieldName = (Core.Name "implementation"), - Core.fieldTerm = (Phantoms.unTTerm implementation)}]})) - -primitiveImplementation :: Phantoms.TTerm Graph.Primitive -> Phantoms.TTerm (Context.Context -> Graph.Graph -> [Core.Term] -> Either (Context.InContext Errors.Error) Core.Term) -primitiveImplementation x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Primitive"), - Core.projectionField = (Core.Name "implementation")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -primitiveName :: Phantoms.TTerm Graph.Primitive -> Phantoms.TTerm Core.Name -primitiveName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Primitive"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -primitiveType :: Phantoms.TTerm Graph.Primitive -> Phantoms.TTerm Core.TypeScheme -primitiveType x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Primitive"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -primitiveWithImplementation :: Phantoms.TTerm Graph.Primitive -> Phantoms.TTerm (Context.Context -> Graph.Graph -> [Core.Term] -> Either (Context.InContext Errors.Error) Core.Term) -> Phantoms.TTerm Graph.Primitive -primitiveWithImplementation original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.graph.Primitive"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Primitive"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Primitive"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "implementation"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -primitiveWithName :: Phantoms.TTerm Graph.Primitive -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Graph.Primitive -primitiveWithName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.graph.Primitive"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Primitive"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "implementation"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Primitive"), - Core.projectionField = (Core.Name "implementation")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -primitiveWithType :: Phantoms.TTerm Graph.Primitive -> Phantoms.TTerm Core.TypeScheme -> Phantoms.TTerm Graph.Primitive -primitiveWithType original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.graph.Primitive"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Primitive"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "implementation"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.Primitive"), - Core.projectionField = (Core.Name "implementation")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -termCoder :: Phantoms.TTerm Core.Type -> Phantoms.TTerm (Context.Context -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) a) -> Phantoms.TTerm (Context.Context -> a -> Either (Context.InContext Errors.Error) Core.Term) -> Phantoms.TTerm (Graph.TermCoder a) -termCoder type_ encode decode = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.graph.TermCoder"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Phantoms.unTTerm type_)}, - Core.Field { - Core.fieldName = (Core.Name "encode"), - Core.fieldTerm = (Phantoms.unTTerm encode)}, - Core.Field { - Core.fieldName = (Core.Name "decode"), - Core.fieldTerm = (Phantoms.unTTerm decode)}]})) - -termCoderDecode :: Phantoms.TTerm (Graph.TermCoder a) -> Phantoms.TTerm (Context.Context -> a -> Either (Context.InContext Errors.Error) Core.Term) -termCoderDecode x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.TermCoder"), - Core.projectionField = (Core.Name "decode")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -termCoderEncode :: Phantoms.TTerm (Graph.TermCoder a) -> Phantoms.TTerm (Context.Context -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) a) -termCoderEncode x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.TermCoder"), - Core.projectionField = (Core.Name "encode")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -termCoderType :: Phantoms.TTerm (Graph.TermCoder a) -> Phantoms.TTerm Core.Type -termCoderType x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.TermCoder"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -termCoderWithDecode :: Phantoms.TTerm (Graph.TermCoder a) -> Phantoms.TTerm (Context.Context -> a -> Either (Context.InContext Errors.Error) Core.Term) -> Phantoms.TTerm (Graph.TermCoder a) -termCoderWithDecode original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.graph.TermCoder"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.TermCoder"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "encode"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.TermCoder"), - Core.projectionField = (Core.Name "encode")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "decode"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -termCoderWithEncode :: Phantoms.TTerm (Graph.TermCoder a) -> Phantoms.TTerm (Context.Context -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) a) -> Phantoms.TTerm (Graph.TermCoder a) -termCoderWithEncode original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.graph.TermCoder"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.TermCoder"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "encode"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "decode"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.TermCoder"), - Core.projectionField = (Core.Name "decode")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -termCoderWithType :: Phantoms.TTerm (Graph.TermCoder a) -> Phantoms.TTerm Core.Type -> Phantoms.TTerm (Graph.TermCoder a) -termCoderWithType original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.graph.TermCoder"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "encode"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.TermCoder"), - Core.projectionField = (Core.Name "encode")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "decode"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.graph.TermCoder"), - Core.projectionField = (Core.Name "decode")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) diff --git a/src/gen-main/haskell/Hydra/Dsl/Json/Model.hs b/src/gen-main/haskell/Hydra/Dsl/Json/Model.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Dsl/Json/Model.hs +++ /dev/null @@ -1,63 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | DSL functions for hydra.json.model - -module Hydra.Dsl.Json.Model where - -import qualified Hydra.Core as Core -import qualified Hydra.Json.Model as Model -import qualified Hydra.Phantoms as Phantoms -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -valueArray :: Phantoms.TTerm [Model.Value] -> Phantoms.TTerm Model.Value -valueArray x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.json.model.Value"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "array"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -valueBoolean :: Phantoms.TTerm Bool -> Phantoms.TTerm Model.Value -valueBoolean x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.json.model.Value"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "boolean"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -valueNull :: Phantoms.TTerm Model.Value -valueNull = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.json.model.Value"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "null"), - Core.fieldTerm = Core.TermUnit}})) - -valueNumber :: Phantoms.TTerm Double -> Phantoms.TTerm Model.Value -valueNumber x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.json.model.Value"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "number"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -valueObject :: Phantoms.TTerm (M.Map String Model.Value) -> Phantoms.TTerm Model.Value -valueObject x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.json.model.Value"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "object"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -valueString :: Phantoms.TTerm String -> Phantoms.TTerm Model.Value -valueString x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.json.model.Value"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) diff --git a/src/gen-main/haskell/Hydra/Dsl/Module.hs b/src/gen-main/haskell/Hydra/Dsl/Module.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Dsl/Module.hs +++ /dev/null @@ -1,698 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | DSL functions for hydra.module - -module Hydra.Dsl.Module where - -import qualified Hydra.Core as Core -import qualified Hydra.Graph as Graph -import qualified Hydra.Module as Module -import qualified Hydra.Phantoms as Phantoms -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -definitionTerm :: Phantoms.TTerm Module.TermDefinition -> Phantoms.TTerm Module.Definition -definitionTerm x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.module.Definition"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -definitionType :: Phantoms.TTerm Module.TypeDefinition -> Phantoms.TTerm Module.Definition -definitionType x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.module.Definition"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -fileExtension :: Phantoms.TTerm String -> Phantoms.TTerm Module.FileExtension -fileExtension x = - Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.module.FileExtension"), - Core.wrappedTermBody = (Phantoms.unTTerm x)})) - -library :: Phantoms.TTerm Module.Namespace -> Phantoms.TTerm String -> Phantoms.TTerm [Graph.Primitive] -> Phantoms.TTerm Module.Library -library namespace prefix primitives = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.module.Library"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "namespace"), - Core.fieldTerm = (Phantoms.unTTerm namespace)}, - Core.Field { - Core.fieldName = (Core.Name "prefix"), - Core.fieldTerm = (Phantoms.unTTerm prefix)}, - Core.Field { - Core.fieldName = (Core.Name "primitives"), - Core.fieldTerm = (Phantoms.unTTerm primitives)}]})) - -libraryNamespace :: Phantoms.TTerm Module.Library -> Phantoms.TTerm Module.Namespace -libraryNamespace x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.module.Library"), - Core.projectionField = (Core.Name "namespace")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -libraryPrefix :: Phantoms.TTerm Module.Library -> Phantoms.TTerm String -libraryPrefix x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.module.Library"), - Core.projectionField = (Core.Name "prefix")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -libraryPrimitives :: Phantoms.TTerm Module.Library -> Phantoms.TTerm [Graph.Primitive] -libraryPrimitives x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.module.Library"), - Core.projectionField = (Core.Name "primitives")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -libraryWithNamespace :: Phantoms.TTerm Module.Library -> Phantoms.TTerm Module.Namespace -> Phantoms.TTerm Module.Library -libraryWithNamespace original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.module.Library"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "namespace"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "prefix"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.module.Library"), - Core.projectionField = (Core.Name "prefix")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "primitives"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.module.Library"), - Core.projectionField = (Core.Name "primitives")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -libraryWithPrefix :: Phantoms.TTerm Module.Library -> Phantoms.TTerm String -> Phantoms.TTerm Module.Library -libraryWithPrefix original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.module.Library"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "namespace"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.module.Library"), - Core.projectionField = (Core.Name "namespace")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "prefix"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "primitives"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.module.Library"), - Core.projectionField = (Core.Name "primitives")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -libraryWithPrimitives :: Phantoms.TTerm Module.Library -> Phantoms.TTerm [Graph.Primitive] -> Phantoms.TTerm Module.Library -libraryWithPrimitives original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.module.Library"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "namespace"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.module.Library"), - Core.projectionField = (Core.Name "namespace")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "prefix"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.module.Library"), - Core.projectionField = (Core.Name "prefix")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "primitives"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -module_ :: Phantoms.TTerm Module.Namespace -> Phantoms.TTerm [Module.Definition] -> Phantoms.TTerm [Module.Namespace] -> Phantoms.TTerm [Module.Namespace] -> Phantoms.TTerm (Maybe String) -> Phantoms.TTerm Module.Module -module_ namespace definitions termDependencies typeDependencies description = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.module.Module"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "namespace"), - Core.fieldTerm = (Phantoms.unTTerm namespace)}, - Core.Field { - Core.fieldName = (Core.Name "definitions"), - Core.fieldTerm = (Phantoms.unTTerm definitions)}, - Core.Field { - Core.fieldName = (Core.Name "termDependencies"), - Core.fieldTerm = (Phantoms.unTTerm termDependencies)}, - Core.Field { - Core.fieldName = (Core.Name "typeDependencies"), - Core.fieldTerm = (Phantoms.unTTerm typeDependencies)}, - Core.Field { - Core.fieldName = (Core.Name "description"), - Core.fieldTerm = (Phantoms.unTTerm description)}]})) - -moduleDefinitions :: Phantoms.TTerm Module.Module -> Phantoms.TTerm [Module.Definition] -moduleDefinitions x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.module.Module"), - Core.projectionField = (Core.Name "definitions")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -moduleDescription :: Phantoms.TTerm Module.Module -> Phantoms.TTerm (Maybe String) -moduleDescription x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.module.Module"), - Core.projectionField = (Core.Name "description")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -moduleNamespace :: Phantoms.TTerm Module.Module -> Phantoms.TTerm Module.Namespace -moduleNamespace x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.module.Module"), - Core.projectionField = (Core.Name "namespace")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -moduleTermDependencies :: Phantoms.TTerm Module.Module -> Phantoms.TTerm [Module.Namespace] -moduleTermDependencies x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.module.Module"), - Core.projectionField = (Core.Name "termDependencies")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -moduleTypeDependencies :: Phantoms.TTerm Module.Module -> Phantoms.TTerm [Module.Namespace] -moduleTypeDependencies x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.module.Module"), - Core.projectionField = (Core.Name "typeDependencies")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -moduleWithDefinitions :: Phantoms.TTerm Module.Module -> Phantoms.TTerm [Module.Definition] -> Phantoms.TTerm Module.Module -moduleWithDefinitions original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.module.Module"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "namespace"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.module.Module"), - Core.projectionField = (Core.Name "namespace")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "definitions"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "termDependencies"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.module.Module"), - Core.projectionField = (Core.Name "termDependencies")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "typeDependencies"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.module.Module"), - Core.projectionField = (Core.Name "typeDependencies")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "description"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.module.Module"), - Core.projectionField = (Core.Name "description")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -moduleWithDescription :: Phantoms.TTerm Module.Module -> Phantoms.TTerm (Maybe String) -> Phantoms.TTerm Module.Module -moduleWithDescription original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.module.Module"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "namespace"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.module.Module"), - Core.projectionField = (Core.Name "namespace")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "definitions"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.module.Module"), - Core.projectionField = (Core.Name "definitions")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "termDependencies"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.module.Module"), - Core.projectionField = (Core.Name "termDependencies")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "typeDependencies"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.module.Module"), - Core.projectionField = (Core.Name "typeDependencies")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "description"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -moduleWithNamespace :: Phantoms.TTerm Module.Module -> Phantoms.TTerm Module.Namespace -> Phantoms.TTerm Module.Module -moduleWithNamespace original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.module.Module"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "namespace"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "definitions"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.module.Module"), - Core.projectionField = (Core.Name "definitions")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "termDependencies"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.module.Module"), - Core.projectionField = (Core.Name "termDependencies")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "typeDependencies"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.module.Module"), - Core.projectionField = (Core.Name "typeDependencies")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "description"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.module.Module"), - Core.projectionField = (Core.Name "description")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -moduleWithTermDependencies :: Phantoms.TTerm Module.Module -> Phantoms.TTerm [Module.Namespace] -> Phantoms.TTerm Module.Module -moduleWithTermDependencies original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.module.Module"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "namespace"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.module.Module"), - Core.projectionField = (Core.Name "namespace")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "definitions"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.module.Module"), - Core.projectionField = (Core.Name "definitions")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "termDependencies"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "typeDependencies"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.module.Module"), - Core.projectionField = (Core.Name "typeDependencies")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "description"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.module.Module"), - Core.projectionField = (Core.Name "description")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -moduleWithTypeDependencies :: Phantoms.TTerm Module.Module -> Phantoms.TTerm [Module.Namespace] -> Phantoms.TTerm Module.Module -moduleWithTypeDependencies original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.module.Module"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "namespace"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.module.Module"), - Core.projectionField = (Core.Name "namespace")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "definitions"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.module.Module"), - Core.projectionField = (Core.Name "definitions")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "termDependencies"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.module.Module"), - Core.projectionField = (Core.Name "termDependencies")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "typeDependencies"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "description"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.module.Module"), - Core.projectionField = (Core.Name "description")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -namespace :: Phantoms.TTerm String -> Phantoms.TTerm Module.Namespace -namespace x = - Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.module.Namespace"), - Core.wrappedTermBody = (Phantoms.unTTerm x)})) - -namespaces :: Phantoms.TTerm (Module.Namespace, n) -> Phantoms.TTerm (M.Map Module.Namespace n) -> Phantoms.TTerm (Module.Namespaces n) -namespaces focus mapping = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.module.Namespaces"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "focus"), - Core.fieldTerm = (Phantoms.unTTerm focus)}, - Core.Field { - Core.fieldName = (Core.Name "mapping"), - Core.fieldTerm = (Phantoms.unTTerm mapping)}]})) - -namespacesFocus :: Phantoms.TTerm (Module.Namespaces n) -> Phantoms.TTerm (Module.Namespace, n) -namespacesFocus x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.module.Namespaces"), - Core.projectionField = (Core.Name "focus")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -namespacesMapping :: Phantoms.TTerm (Module.Namespaces n) -> Phantoms.TTerm (M.Map Module.Namespace n) -namespacesMapping x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.module.Namespaces"), - Core.projectionField = (Core.Name "mapping")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -namespacesWithFocus :: Phantoms.TTerm (Module.Namespaces n) -> Phantoms.TTerm (Module.Namespace, n) -> Phantoms.TTerm (Module.Namespaces n) -namespacesWithFocus original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.module.Namespaces"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "focus"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "mapping"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.module.Namespaces"), - Core.projectionField = (Core.Name "mapping")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -namespacesWithMapping :: Phantoms.TTerm (Module.Namespaces n) -> Phantoms.TTerm (M.Map Module.Namespace n) -> Phantoms.TTerm (Module.Namespaces n) -namespacesWithMapping original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.module.Namespaces"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "focus"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.module.Namespaces"), - Core.projectionField = (Core.Name "focus")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "mapping"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -qualifiedName :: Phantoms.TTerm (Maybe Module.Namespace) -> Phantoms.TTerm String -> Phantoms.TTerm Module.QualifiedName -qualifiedName namespace local = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.module.QualifiedName"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "namespace"), - Core.fieldTerm = (Phantoms.unTTerm namespace)}, - Core.Field { - Core.fieldName = (Core.Name "local"), - Core.fieldTerm = (Phantoms.unTTerm local)}]})) - -qualifiedNameLocal :: Phantoms.TTerm Module.QualifiedName -> Phantoms.TTerm String -qualifiedNameLocal x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.module.QualifiedName"), - Core.projectionField = (Core.Name "local")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -qualifiedNameNamespace :: Phantoms.TTerm Module.QualifiedName -> Phantoms.TTerm (Maybe Module.Namespace) -qualifiedNameNamespace x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.module.QualifiedName"), - Core.projectionField = (Core.Name "namespace")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -qualifiedNameWithLocal :: Phantoms.TTerm Module.QualifiedName -> Phantoms.TTerm String -> Phantoms.TTerm Module.QualifiedName -qualifiedNameWithLocal original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.module.QualifiedName"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "namespace"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.module.QualifiedName"), - Core.projectionField = (Core.Name "namespace")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "local"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -qualifiedNameWithNamespace :: Phantoms.TTerm Module.QualifiedName -> Phantoms.TTerm (Maybe Module.Namespace) -> Phantoms.TTerm Module.QualifiedName -qualifiedNameWithNamespace original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.module.QualifiedName"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "namespace"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "local"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.module.QualifiedName"), - Core.projectionField = (Core.Name "local")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -termDefinition :: Phantoms.TTerm Core.Name -> Phantoms.TTerm Core.Term -> Phantoms.TTerm (Maybe Core.TypeScheme) -> Phantoms.TTerm Module.TermDefinition -termDefinition name term type_ = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.module.TermDefinition"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm name)}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Phantoms.unTTerm term)}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Phantoms.unTTerm type_)}]})) - -termDefinitionName :: Phantoms.TTerm Module.TermDefinition -> Phantoms.TTerm Core.Name -termDefinitionName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.module.TermDefinition"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -termDefinitionTerm :: Phantoms.TTerm Module.TermDefinition -> Phantoms.TTerm Core.Term -termDefinitionTerm x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.module.TermDefinition"), - Core.projectionField = (Core.Name "term")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -termDefinitionType :: Phantoms.TTerm Module.TermDefinition -> Phantoms.TTerm (Maybe Core.TypeScheme) -termDefinitionType x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.module.TermDefinition"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -termDefinitionWithName :: Phantoms.TTerm Module.TermDefinition -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Module.TermDefinition -termDefinitionWithName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.module.TermDefinition"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.module.TermDefinition"), - Core.projectionField = (Core.Name "term")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.module.TermDefinition"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -termDefinitionWithTerm :: Phantoms.TTerm Module.TermDefinition -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Module.TermDefinition -termDefinitionWithTerm original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.module.TermDefinition"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.module.TermDefinition"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.module.TermDefinition"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -termDefinitionWithType :: Phantoms.TTerm Module.TermDefinition -> Phantoms.TTerm (Maybe Core.TypeScheme) -> Phantoms.TTerm Module.TermDefinition -termDefinitionWithType original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.module.TermDefinition"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.module.TermDefinition"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.module.TermDefinition"), - Core.projectionField = (Core.Name "term")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -typeDefinition :: Phantoms.TTerm Core.Name -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Module.TypeDefinition -typeDefinition name type_ = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.module.TypeDefinition"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm name)}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Phantoms.unTTerm type_)}]})) - -typeDefinitionName :: Phantoms.TTerm Module.TypeDefinition -> Phantoms.TTerm Core.Name -typeDefinitionName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.module.TypeDefinition"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -typeDefinitionType :: Phantoms.TTerm Module.TypeDefinition -> Phantoms.TTerm Core.Type -typeDefinitionType x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.module.TypeDefinition"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -typeDefinitionWithName :: Phantoms.TTerm Module.TypeDefinition -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Module.TypeDefinition -typeDefinitionWithName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.module.TypeDefinition"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.module.TypeDefinition"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -typeDefinitionWithType :: Phantoms.TTerm Module.TypeDefinition -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Module.TypeDefinition -typeDefinitionWithType original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.module.TypeDefinition"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.module.TypeDefinition"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -unFileExtension :: Phantoms.TTerm Module.FileExtension -> Phantoms.TTerm String -unFileExtension x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.module.FileExtension")))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -unNamespace :: Phantoms.TTerm Module.Namespace -> Phantoms.TTerm String -unNamespace x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.module.Namespace")))), - Core.applicationArgument = (Phantoms.unTTerm x)})) diff --git a/src/gen-main/haskell/Hydra/Dsl/Packaging.hs b/src/gen-main/haskell/Hydra/Dsl/Packaging.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Dsl/Packaging.hs +++ /dev/null @@ -1,198 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | DSL functions for hydra.packaging - -module Hydra.Dsl.Packaging where - -import qualified Hydra.Core as Core -import qualified Hydra.Module as Module -import qualified Hydra.Packaging as Packaging -import qualified Hydra.Phantoms as Phantoms -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -package :: Phantoms.TTerm Packaging.PackageName -> Phantoms.TTerm [Module.Module] -> Phantoms.TTerm [Packaging.PackageName] -> Phantoms.TTerm (Maybe String) -> Phantoms.TTerm Packaging.Package -package name modules dependencies description = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.packaging.Package"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm name)}, - Core.Field { - Core.fieldName = (Core.Name "modules"), - Core.fieldTerm = (Phantoms.unTTerm modules)}, - Core.Field { - Core.fieldName = (Core.Name "dependencies"), - Core.fieldTerm = (Phantoms.unTTerm dependencies)}, - Core.Field { - Core.fieldName = (Core.Name "description"), - Core.fieldTerm = (Phantoms.unTTerm description)}]})) - -packageDependencies :: Phantoms.TTerm Packaging.Package -> Phantoms.TTerm [Packaging.PackageName] -packageDependencies x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.packaging.Package"), - Core.projectionField = (Core.Name "dependencies")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -packageDescription :: Phantoms.TTerm Packaging.Package -> Phantoms.TTerm (Maybe String) -packageDescription x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.packaging.Package"), - Core.projectionField = (Core.Name "description")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -packageModules :: Phantoms.TTerm Packaging.Package -> Phantoms.TTerm [Module.Module] -packageModules x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.packaging.Package"), - Core.projectionField = (Core.Name "modules")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -packageName :: Phantoms.TTerm Packaging.Package -> Phantoms.TTerm Packaging.PackageName -packageName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.packaging.Package"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -packageName_ :: Phantoms.TTerm String -> Phantoms.TTerm Packaging.PackageName -packageName_ x = - Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.packaging.PackageName"), - Core.wrappedTermBody = (Phantoms.unTTerm x)})) - -packageWithDependencies :: Phantoms.TTerm Packaging.Package -> Phantoms.TTerm [Packaging.PackageName] -> Phantoms.TTerm Packaging.Package -packageWithDependencies original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.packaging.Package"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.packaging.Package"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "modules"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.packaging.Package"), - Core.projectionField = (Core.Name "modules")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "dependencies"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "description"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.packaging.Package"), - Core.projectionField = (Core.Name "description")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -packageWithDescription :: Phantoms.TTerm Packaging.Package -> Phantoms.TTerm (Maybe String) -> Phantoms.TTerm Packaging.Package -packageWithDescription original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.packaging.Package"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.packaging.Package"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "modules"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.packaging.Package"), - Core.projectionField = (Core.Name "modules")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "dependencies"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.packaging.Package"), - Core.projectionField = (Core.Name "dependencies")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "description"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -packageWithModules :: Phantoms.TTerm Packaging.Package -> Phantoms.TTerm [Module.Module] -> Phantoms.TTerm Packaging.Package -packageWithModules original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.packaging.Package"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.packaging.Package"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "modules"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "dependencies"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.packaging.Package"), - Core.projectionField = (Core.Name "dependencies")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "description"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.packaging.Package"), - Core.projectionField = (Core.Name "description")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -packageWithName :: Phantoms.TTerm Packaging.Package -> Phantoms.TTerm Packaging.PackageName -> Phantoms.TTerm Packaging.Package -packageWithName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.packaging.Package"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "modules"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.packaging.Package"), - Core.projectionField = (Core.Name "modules")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "dependencies"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.packaging.Package"), - Core.projectionField = (Core.Name "dependencies")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "description"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.packaging.Package"), - Core.projectionField = (Core.Name "description")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -unPackageName :: Phantoms.TTerm Packaging.PackageName -> Phantoms.TTerm String -unPackageName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.packaging.PackageName")))), - Core.applicationArgument = (Phantoms.unTTerm x)})) diff --git a/src/gen-main/haskell/Hydra/Dsl/Parsing.hs b/src/gen-main/haskell/Hydra/Dsl/Parsing.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Dsl/Parsing.hs +++ /dev/null @@ -1,163 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | DSL functions for hydra.parsing - -module Hydra.Dsl.Parsing where - -import qualified Hydra.Core as Core -import qualified Hydra.Parsing as Parsing -import qualified Hydra.Phantoms as Phantoms -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -parseError :: Phantoms.TTerm String -> Phantoms.TTerm String -> Phantoms.TTerm Parsing.ParseError -parseError message remainder = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.parsing.ParseError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "message"), - Core.fieldTerm = (Phantoms.unTTerm message)}, - Core.Field { - Core.fieldName = (Core.Name "remainder"), - Core.fieldTerm = (Phantoms.unTTerm remainder)}]})) - -parseErrorMessage :: Phantoms.TTerm Parsing.ParseError -> Phantoms.TTerm String -parseErrorMessage x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.parsing.ParseError"), - Core.projectionField = (Core.Name "message")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -parseErrorRemainder :: Phantoms.TTerm Parsing.ParseError -> Phantoms.TTerm String -parseErrorRemainder x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.parsing.ParseError"), - Core.projectionField = (Core.Name "remainder")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -parseErrorWithMessage :: Phantoms.TTerm Parsing.ParseError -> Phantoms.TTerm String -> Phantoms.TTerm Parsing.ParseError -parseErrorWithMessage original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.parsing.ParseError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "message"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "remainder"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.parsing.ParseError"), - Core.projectionField = (Core.Name "remainder")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -parseErrorWithRemainder :: Phantoms.TTerm Parsing.ParseError -> Phantoms.TTerm String -> Phantoms.TTerm Parsing.ParseError -parseErrorWithRemainder original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.parsing.ParseError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "message"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.parsing.ParseError"), - Core.projectionField = (Core.Name "message")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "remainder"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -parseResultFailure :: Phantoms.TTerm Parsing.ParseError -> Phantoms.TTerm (Parsing.ParseResult a) -parseResultFailure x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.parsing.ParseResult"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "failure"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -parseResultSuccess :: Phantoms.TTerm (Parsing.ParseSuccess a) -> Phantoms.TTerm (Parsing.ParseResult a) -parseResultSuccess x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.parsing.ParseResult"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "success"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -parseSuccess :: Phantoms.TTerm a -> Phantoms.TTerm String -> Phantoms.TTerm (Parsing.ParseSuccess a) -parseSuccess value remainder = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.parsing.ParseSuccess"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "value"), - Core.fieldTerm = (Phantoms.unTTerm value)}, - Core.Field { - Core.fieldName = (Core.Name "remainder"), - Core.fieldTerm = (Phantoms.unTTerm remainder)}]})) - -parseSuccessRemainder :: Phantoms.TTerm (Parsing.ParseSuccess a) -> Phantoms.TTerm String -parseSuccessRemainder x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.parsing.ParseSuccess"), - Core.projectionField = (Core.Name "remainder")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -parseSuccessValue :: Phantoms.TTerm (Parsing.ParseSuccess a) -> Phantoms.TTerm a -parseSuccessValue x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.parsing.ParseSuccess"), - Core.projectionField = (Core.Name "value")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -parseSuccessWithRemainder :: Phantoms.TTerm (Parsing.ParseSuccess a) -> Phantoms.TTerm String -> Phantoms.TTerm (Parsing.ParseSuccess a) -parseSuccessWithRemainder original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.parsing.ParseSuccess"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "value"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.parsing.ParseSuccess"), - Core.projectionField = (Core.Name "value")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "remainder"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -parseSuccessWithValue :: Phantoms.TTerm (Parsing.ParseSuccess a) -> Phantoms.TTerm a -> Phantoms.TTerm (Parsing.ParseSuccess a) -parseSuccessWithValue original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.parsing.ParseSuccess"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "value"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "remainder"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.parsing.ParseSuccess"), - Core.projectionField = (Core.Name "remainder")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -parser :: Phantoms.TTerm (String -> Parsing.ParseResult a) -> Phantoms.TTerm (Parsing.Parser a) -parser x = - Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.parsing.Parser"), - Core.wrappedTermBody = (Phantoms.unTTerm x)})) - -unParser :: Phantoms.TTerm (Parsing.Parser a) -> Phantoms.TTerm (String -> Parsing.ParseResult a) -unParser x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.parsing.Parser")))), - Core.applicationArgument = (Phantoms.unTTerm x)})) diff --git a/src/gen-main/haskell/Hydra/Dsl/Paths.hs b/src/gen-main/haskell/Hydra/Dsl/Paths.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Dsl/Paths.hs +++ /dev/null @@ -1,895 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | DSL functions for hydra.paths - -module Hydra.Dsl.Paths where - -import qualified Hydra.Core as Core -import qualified Hydra.Paths as Paths -import qualified Hydra.Phantoms as Phantoms -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -subtermEdge :: Phantoms.TTerm Paths.SubtermNode -> Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Paths.SubtermNode -> Phantoms.TTerm Paths.SubtermEdge -subtermEdge source path target = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.paths.SubtermEdge"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "source"), - Core.fieldTerm = (Phantoms.unTTerm source)}, - Core.Field { - Core.fieldName = (Core.Name "path"), - Core.fieldTerm = (Phantoms.unTTerm path)}, - Core.Field { - Core.fieldName = (Core.Name "target"), - Core.fieldTerm = (Phantoms.unTTerm target)}]})) - -subtermEdgePath :: Phantoms.TTerm Paths.SubtermEdge -> Phantoms.TTerm Paths.SubtermPath -subtermEdgePath x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtermEdge"), - Core.projectionField = (Core.Name "path")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -subtermEdgeSource :: Phantoms.TTerm Paths.SubtermEdge -> Phantoms.TTerm Paths.SubtermNode -subtermEdgeSource x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtermEdge"), - Core.projectionField = (Core.Name "source")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -subtermEdgeTarget :: Phantoms.TTerm Paths.SubtermEdge -> Phantoms.TTerm Paths.SubtermNode -subtermEdgeTarget x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtermEdge"), - Core.projectionField = (Core.Name "target")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -subtermEdgeWithPath :: Phantoms.TTerm Paths.SubtermEdge -> Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm Paths.SubtermEdge -subtermEdgeWithPath original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.paths.SubtermEdge"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "source"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtermEdge"), - Core.projectionField = (Core.Name "source")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "path"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "target"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtermEdge"), - Core.projectionField = (Core.Name "target")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -subtermEdgeWithSource :: Phantoms.TTerm Paths.SubtermEdge -> Phantoms.TTerm Paths.SubtermNode -> Phantoms.TTerm Paths.SubtermEdge -subtermEdgeWithSource original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.paths.SubtermEdge"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "source"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "path"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtermEdge"), - Core.projectionField = (Core.Name "path")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "target"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtermEdge"), - Core.projectionField = (Core.Name "target")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -subtermEdgeWithTarget :: Phantoms.TTerm Paths.SubtermEdge -> Phantoms.TTerm Paths.SubtermNode -> Phantoms.TTerm Paths.SubtermEdge -subtermEdgeWithTarget original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.paths.SubtermEdge"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "source"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtermEdge"), - Core.projectionField = (Core.Name "source")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "path"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtermEdge"), - Core.projectionField = (Core.Name "path")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "target"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -subtermGraph :: Phantoms.TTerm [Paths.SubtermNode] -> Phantoms.TTerm [Paths.SubtermEdge] -> Phantoms.TTerm Paths.SubtermGraph -subtermGraph nodes edges = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.paths.SubtermGraph"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "nodes"), - Core.fieldTerm = (Phantoms.unTTerm nodes)}, - Core.Field { - Core.fieldName = (Core.Name "edges"), - Core.fieldTerm = (Phantoms.unTTerm edges)}]})) - -subtermGraphEdges :: Phantoms.TTerm Paths.SubtermGraph -> Phantoms.TTerm [Paths.SubtermEdge] -subtermGraphEdges x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtermGraph"), - Core.projectionField = (Core.Name "edges")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -subtermGraphNodes :: Phantoms.TTerm Paths.SubtermGraph -> Phantoms.TTerm [Paths.SubtermNode] -subtermGraphNodes x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtermGraph"), - Core.projectionField = (Core.Name "nodes")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -subtermGraphWithEdges :: Phantoms.TTerm Paths.SubtermGraph -> Phantoms.TTerm [Paths.SubtermEdge] -> Phantoms.TTerm Paths.SubtermGraph -subtermGraphWithEdges original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.paths.SubtermGraph"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "nodes"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtermGraph"), - Core.projectionField = (Core.Name "nodes")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "edges"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -subtermGraphWithNodes :: Phantoms.TTerm Paths.SubtermGraph -> Phantoms.TTerm [Paths.SubtermNode] -> Phantoms.TTerm Paths.SubtermGraph -subtermGraphWithNodes original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.paths.SubtermGraph"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "nodes"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "edges"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtermGraph"), - Core.projectionField = (Core.Name "edges")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -subtermNode :: Phantoms.TTerm Core.Name -> Phantoms.TTerm String -> Phantoms.TTerm String -> Phantoms.TTerm Paths.SubtermNode -subtermNode name label id = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.paths.SubtermNode"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm name)}, - Core.Field { - Core.fieldName = (Core.Name "label"), - Core.fieldTerm = (Phantoms.unTTerm label)}, - Core.Field { - Core.fieldName = (Core.Name "id"), - Core.fieldTerm = (Phantoms.unTTerm id)}]})) - -subtermNodeId :: Phantoms.TTerm Paths.SubtermNode -> Phantoms.TTerm String -subtermNodeId x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtermNode"), - Core.projectionField = (Core.Name "id")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -subtermNodeLabel :: Phantoms.TTerm Paths.SubtermNode -> Phantoms.TTerm String -subtermNodeLabel x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtermNode"), - Core.projectionField = (Core.Name "label")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -subtermNodeName :: Phantoms.TTerm Paths.SubtermNode -> Phantoms.TTerm Core.Name -subtermNodeName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtermNode"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -subtermNodeWithId :: Phantoms.TTerm Paths.SubtermNode -> Phantoms.TTerm String -> Phantoms.TTerm Paths.SubtermNode -subtermNodeWithId original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.paths.SubtermNode"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtermNode"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "label"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtermNode"), - Core.projectionField = (Core.Name "label")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "id"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -subtermNodeWithLabel :: Phantoms.TTerm Paths.SubtermNode -> Phantoms.TTerm String -> Phantoms.TTerm Paths.SubtermNode -subtermNodeWithLabel original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.paths.SubtermNode"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtermNode"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "label"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "id"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtermNode"), - Core.projectionField = (Core.Name "id")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -subtermNodeWithName :: Phantoms.TTerm Paths.SubtermNode -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Paths.SubtermNode -subtermNodeWithName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.paths.SubtermNode"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "label"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtermNode"), - Core.projectionField = (Core.Name "label")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "id"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtermNode"), - Core.projectionField = (Core.Name "id")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -subtermPath :: Phantoms.TTerm [Paths.SubtermStep] -> Phantoms.TTerm Paths.SubtermPath -subtermPath x = - Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.paths.SubtermPath"), - Core.wrappedTermBody = (Phantoms.unTTerm x)})) - -subtermStepAnnotatedBody :: Phantoms.TTerm Paths.SubtermStep -subtermStepAnnotatedBody = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "annotatedBody"), - Core.fieldTerm = Core.TermUnit}})) - -subtermStepApplicationArgument :: Phantoms.TTerm Paths.SubtermStep -subtermStepApplicationArgument = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "applicationArgument"), - Core.fieldTerm = Core.TermUnit}})) - -subtermStepApplicationFunction :: Phantoms.TTerm Paths.SubtermStep -subtermStepApplicationFunction = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "applicationFunction"), - Core.fieldTerm = Core.TermUnit}})) - -subtermStepInjectionTerm :: Phantoms.TTerm Paths.SubtermStep -subtermStepInjectionTerm = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "injectionTerm"), - Core.fieldTerm = Core.TermUnit}})) - -subtermStepLambdaBody :: Phantoms.TTerm Paths.SubtermStep -subtermStepLambdaBody = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "lambdaBody"), - Core.fieldTerm = Core.TermUnit}})) - -subtermStepLetBinding :: Phantoms.TTerm Core.Name -> Phantoms.TTerm Paths.SubtermStep -subtermStepLetBinding x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "letBinding"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -subtermStepLetBody :: Phantoms.TTerm Paths.SubtermStep -subtermStepLetBody = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "letBody"), - Core.fieldTerm = Core.TermUnit}})) - -subtermStepListElement :: Phantoms.TTerm Int -> Phantoms.TTerm Paths.SubtermStep -subtermStepListElement x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "listElement"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -subtermStepMapKey :: Phantoms.TTerm Int -> Phantoms.TTerm Paths.SubtermStep -subtermStepMapKey x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "mapKey"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -subtermStepMapValue :: Phantoms.TTerm Int -> Phantoms.TTerm Paths.SubtermStep -subtermStepMapValue x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "mapValue"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -subtermStepMaybeTerm :: Phantoms.TTerm Paths.SubtermStep -subtermStepMaybeTerm = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "maybeTerm"), - Core.fieldTerm = Core.TermUnit}})) - -subtermStepProductTerm :: Phantoms.TTerm Int -> Phantoms.TTerm Paths.SubtermStep -subtermStepProductTerm x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "productTerm"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -subtermStepRecordField :: Phantoms.TTerm Core.Name -> Phantoms.TTerm Paths.SubtermStep -subtermStepRecordField x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "recordField"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -subtermStepSetElement :: Phantoms.TTerm Int -> Phantoms.TTerm Paths.SubtermStep -subtermStepSetElement x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "setElement"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -subtermStepSumTerm :: Phantoms.TTerm Paths.SubtermStep -subtermStepSumTerm = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "sumTerm"), - Core.fieldTerm = Core.TermUnit}})) - -subtermStepTypeApplicationTerm :: Phantoms.TTerm Paths.SubtermStep -subtermStepTypeApplicationTerm = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "typeApplicationTerm"), - Core.fieldTerm = Core.TermUnit}})) - -subtermStepTypeLambdaBody :: Phantoms.TTerm Paths.SubtermStep -subtermStepTypeLambdaBody = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "typeLambdaBody"), - Core.fieldTerm = Core.TermUnit}})) - -subtermStepUnionCasesBranch :: Phantoms.TTerm Core.Name -> Phantoms.TTerm Paths.SubtermStep -subtermStepUnionCasesBranch x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unionCasesBranch"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -subtermStepUnionCasesDefault :: Phantoms.TTerm Paths.SubtermStep -subtermStepUnionCasesDefault = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unionCasesDefault"), - Core.fieldTerm = Core.TermUnit}})) - -subtermStepWrappedTerm :: Phantoms.TTerm Paths.SubtermStep -subtermStepWrappedTerm = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wrappedTerm"), - Core.fieldTerm = Core.TermUnit}})) - -subtypeEdge :: Phantoms.TTerm Paths.SubtypeNode -> Phantoms.TTerm Paths.SubtypePath -> Phantoms.TTerm Paths.SubtypeNode -> Phantoms.TTerm Paths.SubtypeEdge -subtypeEdge source path target = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.paths.SubtypeEdge"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "source"), - Core.fieldTerm = (Phantoms.unTTerm source)}, - Core.Field { - Core.fieldName = (Core.Name "path"), - Core.fieldTerm = (Phantoms.unTTerm path)}, - Core.Field { - Core.fieldName = (Core.Name "target"), - Core.fieldTerm = (Phantoms.unTTerm target)}]})) - -subtypeEdgePath :: Phantoms.TTerm Paths.SubtypeEdge -> Phantoms.TTerm Paths.SubtypePath -subtypeEdgePath x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeEdge"), - Core.projectionField = (Core.Name "path")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -subtypeEdgeSource :: Phantoms.TTerm Paths.SubtypeEdge -> Phantoms.TTerm Paths.SubtypeNode -subtypeEdgeSource x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeEdge"), - Core.projectionField = (Core.Name "source")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -subtypeEdgeTarget :: Phantoms.TTerm Paths.SubtypeEdge -> Phantoms.TTerm Paths.SubtypeNode -subtypeEdgeTarget x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeEdge"), - Core.projectionField = (Core.Name "target")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -subtypeEdgeWithPath :: Phantoms.TTerm Paths.SubtypeEdge -> Phantoms.TTerm Paths.SubtypePath -> Phantoms.TTerm Paths.SubtypeEdge -subtypeEdgeWithPath original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.paths.SubtypeEdge"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "source"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeEdge"), - Core.projectionField = (Core.Name "source")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "path"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "target"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeEdge"), - Core.projectionField = (Core.Name "target")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -subtypeEdgeWithSource :: Phantoms.TTerm Paths.SubtypeEdge -> Phantoms.TTerm Paths.SubtypeNode -> Phantoms.TTerm Paths.SubtypeEdge -subtypeEdgeWithSource original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.paths.SubtypeEdge"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "source"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "path"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeEdge"), - Core.projectionField = (Core.Name "path")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "target"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeEdge"), - Core.projectionField = (Core.Name "target")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -subtypeEdgeWithTarget :: Phantoms.TTerm Paths.SubtypeEdge -> Phantoms.TTerm Paths.SubtypeNode -> Phantoms.TTerm Paths.SubtypeEdge -subtypeEdgeWithTarget original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.paths.SubtypeEdge"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "source"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeEdge"), - Core.projectionField = (Core.Name "source")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "path"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeEdge"), - Core.projectionField = (Core.Name "path")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "target"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -subtypeGraph :: Phantoms.TTerm [Paths.SubtypeNode] -> Phantoms.TTerm [Paths.SubtypeEdge] -> Phantoms.TTerm Paths.SubtypeGraph -subtypeGraph nodes edges = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.paths.SubtypeGraph"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "nodes"), - Core.fieldTerm = (Phantoms.unTTerm nodes)}, - Core.Field { - Core.fieldName = (Core.Name "edges"), - Core.fieldTerm = (Phantoms.unTTerm edges)}]})) - -subtypeGraphEdges :: Phantoms.TTerm Paths.SubtypeGraph -> Phantoms.TTerm [Paths.SubtypeEdge] -subtypeGraphEdges x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeGraph"), - Core.projectionField = (Core.Name "edges")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -subtypeGraphNodes :: Phantoms.TTerm Paths.SubtypeGraph -> Phantoms.TTerm [Paths.SubtypeNode] -subtypeGraphNodes x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeGraph"), - Core.projectionField = (Core.Name "nodes")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -subtypeGraphWithEdges :: Phantoms.TTerm Paths.SubtypeGraph -> Phantoms.TTerm [Paths.SubtypeEdge] -> Phantoms.TTerm Paths.SubtypeGraph -subtypeGraphWithEdges original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.paths.SubtypeGraph"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "nodes"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeGraph"), - Core.projectionField = (Core.Name "nodes")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "edges"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -subtypeGraphWithNodes :: Phantoms.TTerm Paths.SubtypeGraph -> Phantoms.TTerm [Paths.SubtypeNode] -> Phantoms.TTerm Paths.SubtypeGraph -subtypeGraphWithNodes original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.paths.SubtypeGraph"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "nodes"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "edges"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeGraph"), - Core.projectionField = (Core.Name "edges")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -subtypeNode :: Phantoms.TTerm Core.Name -> Phantoms.TTerm String -> Phantoms.TTerm String -> Phantoms.TTerm Paths.SubtypeNode -subtypeNode name label id = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.paths.SubtypeNode"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm name)}, - Core.Field { - Core.fieldName = (Core.Name "label"), - Core.fieldTerm = (Phantoms.unTTerm label)}, - Core.Field { - Core.fieldName = (Core.Name "id"), - Core.fieldTerm = (Phantoms.unTTerm id)}]})) - -subtypeNodeId :: Phantoms.TTerm Paths.SubtypeNode -> Phantoms.TTerm String -subtypeNodeId x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeNode"), - Core.projectionField = (Core.Name "id")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -subtypeNodeLabel :: Phantoms.TTerm Paths.SubtypeNode -> Phantoms.TTerm String -subtypeNodeLabel x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeNode"), - Core.projectionField = (Core.Name "label")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -subtypeNodeName :: Phantoms.TTerm Paths.SubtypeNode -> Phantoms.TTerm Core.Name -subtypeNodeName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeNode"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -subtypeNodeWithId :: Phantoms.TTerm Paths.SubtypeNode -> Phantoms.TTerm String -> Phantoms.TTerm Paths.SubtypeNode -subtypeNodeWithId original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.paths.SubtypeNode"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeNode"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "label"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeNode"), - Core.projectionField = (Core.Name "label")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "id"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -subtypeNodeWithLabel :: Phantoms.TTerm Paths.SubtypeNode -> Phantoms.TTerm String -> Phantoms.TTerm Paths.SubtypeNode -subtypeNodeWithLabel original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.paths.SubtypeNode"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeNode"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "label"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "id"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeNode"), - Core.projectionField = (Core.Name "id")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -subtypeNodeWithName :: Phantoms.TTerm Paths.SubtypeNode -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Paths.SubtypeNode -subtypeNodeWithName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.paths.SubtypeNode"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "label"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeNode"), - Core.projectionField = (Core.Name "label")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "id"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeNode"), - Core.projectionField = (Core.Name "id")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -subtypePath :: Phantoms.TTerm [Paths.SubtypeStep] -> Phantoms.TTerm Paths.SubtypePath -subtypePath x = - Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.paths.SubtypePath"), - Core.wrappedTermBody = (Phantoms.unTTerm x)})) - -subtypeStepAnnotatedBody :: Phantoms.TTerm Paths.SubtypeStep -subtypeStepAnnotatedBody = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "annotatedBody"), - Core.fieldTerm = Core.TermUnit}})) - -subtypeStepApplicationArgument :: Phantoms.TTerm Paths.SubtypeStep -subtypeStepApplicationArgument = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "applicationArgument"), - Core.fieldTerm = Core.TermUnit}})) - -subtypeStepApplicationFunction :: Phantoms.TTerm Paths.SubtypeStep -subtypeStepApplicationFunction = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "applicationFunction"), - Core.fieldTerm = Core.TermUnit}})) - -subtypeStepEitherLeft :: Phantoms.TTerm Paths.SubtypeStep -subtypeStepEitherLeft = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "eitherLeft"), - Core.fieldTerm = Core.TermUnit}})) - -subtypeStepEitherRight :: Phantoms.TTerm Paths.SubtypeStep -subtypeStepEitherRight = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "eitherRight"), - Core.fieldTerm = Core.TermUnit}})) - -subtypeStepForallBody :: Phantoms.TTerm Paths.SubtypeStep -subtypeStepForallBody = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "forallBody"), - Core.fieldTerm = Core.TermUnit}})) - -subtypeStepFunctionCodomain :: Phantoms.TTerm Paths.SubtypeStep -subtypeStepFunctionCodomain = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "functionCodomain"), - Core.fieldTerm = Core.TermUnit}})) - -subtypeStepFunctionDomain :: Phantoms.TTerm Paths.SubtypeStep -subtypeStepFunctionDomain = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "functionDomain"), - Core.fieldTerm = Core.TermUnit}})) - -subtypeStepListElement :: Phantoms.TTerm Paths.SubtypeStep -subtypeStepListElement = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "listElement"), - Core.fieldTerm = Core.TermUnit}})) - -subtypeStepMapKeys :: Phantoms.TTerm Paths.SubtypeStep -subtypeStepMapKeys = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "mapKeys"), - Core.fieldTerm = Core.TermUnit}})) - -subtypeStepMapValues :: Phantoms.TTerm Paths.SubtypeStep -subtypeStepMapValues = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "mapValues"), - Core.fieldTerm = Core.TermUnit}})) - -subtypeStepMaybeElement :: Phantoms.TTerm Paths.SubtypeStep -subtypeStepMaybeElement = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "maybeElement"), - Core.fieldTerm = Core.TermUnit}})) - -subtypeStepPairFirst :: Phantoms.TTerm Paths.SubtypeStep -subtypeStepPairFirst = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "pairFirst"), - Core.fieldTerm = Core.TermUnit}})) - -subtypeStepPairSecond :: Phantoms.TTerm Paths.SubtypeStep -subtypeStepPairSecond = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "pairSecond"), - Core.fieldTerm = Core.TermUnit}})) - -subtypeStepRecordField :: Phantoms.TTerm Core.Name -> Phantoms.TTerm Paths.SubtypeStep -subtypeStepRecordField x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "recordField"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -subtypeStepSetElement :: Phantoms.TTerm Paths.SubtypeStep -subtypeStepSetElement = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "setElement"), - Core.fieldTerm = Core.TermUnit}})) - -subtypeStepUnionField :: Phantoms.TTerm Core.Name -> Phantoms.TTerm Paths.SubtypeStep -subtypeStepUnionField x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unionField"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -subtypeStepWrappedType :: Phantoms.TTerm Paths.SubtypeStep -subtypeStepWrappedType = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wrappedType"), - Core.fieldTerm = Core.TermUnit}})) - -unSubtermPath :: Phantoms.TTerm Paths.SubtermPath -> Phantoms.TTerm [Paths.SubtermStep] -unSubtermPath x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.paths.SubtermPath")))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -unSubtypePath :: Phantoms.TTerm Paths.SubtypePath -> Phantoms.TTerm [Paths.SubtypeStep] -unSubtypePath x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.paths.SubtypePath")))), - Core.applicationArgument = (Phantoms.unTTerm x)})) diff --git a/src/gen-main/haskell/Hydra/Dsl/Query.hs b/src/gen-main/haskell/Hydra/Dsl/Query.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Dsl/Query.hs +++ /dev/null @@ -1,819 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | DSL functions for hydra.query - -module Hydra.Dsl.Query where - -import qualified Hydra.Core as Core -import qualified Hydra.Phantoms as Phantoms -import qualified Hydra.Query as Query -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -comparisonConstraintEqual :: Phantoms.TTerm Query.ComparisonConstraint -comparisonConstraintEqual = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.ComparisonConstraint"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "equal"), - Core.fieldTerm = Core.TermUnit}})) - -comparisonConstraintGreaterThan :: Phantoms.TTerm Query.ComparisonConstraint -comparisonConstraintGreaterThan = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.ComparisonConstraint"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "greaterThan"), - Core.fieldTerm = Core.TermUnit}})) - -comparisonConstraintGreaterThanOrEqual :: Phantoms.TTerm Query.ComparisonConstraint -comparisonConstraintGreaterThanOrEqual = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.ComparisonConstraint"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "greaterThanOrEqual"), - Core.fieldTerm = Core.TermUnit}})) - -comparisonConstraintLessThan :: Phantoms.TTerm Query.ComparisonConstraint -comparisonConstraintLessThan = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.ComparisonConstraint"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "lessThan"), - Core.fieldTerm = Core.TermUnit}})) - -comparisonConstraintLessThanOrEqual :: Phantoms.TTerm Query.ComparisonConstraint -comparisonConstraintLessThanOrEqual = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.ComparisonConstraint"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "lessThanOrEqual"), - Core.fieldTerm = Core.TermUnit}})) - -comparisonConstraintNotEqual :: Phantoms.TTerm Query.ComparisonConstraint -comparisonConstraintNotEqual = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.ComparisonConstraint"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "notEqual"), - Core.fieldTerm = Core.TermUnit}})) - -edge :: Phantoms.TTerm Core.Name -> Phantoms.TTerm (Maybe Core.Name) -> Phantoms.TTerm (Maybe Core.Name) -> Phantoms.TTerm Query.Edge -edge type_ out in_ = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.query.Edge"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Phantoms.unTTerm type_)}, - Core.Field { - Core.fieldName = (Core.Name "out"), - Core.fieldTerm = (Phantoms.unTTerm out)}, - Core.Field { - Core.fieldName = (Core.Name "in"), - Core.fieldTerm = (Phantoms.unTTerm in_)}]})) - -edgeIn :: Phantoms.TTerm Query.Edge -> Phantoms.TTerm (Maybe Core.Name) -edgeIn x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.Edge"), - Core.projectionField = (Core.Name "in")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -edgeOut :: Phantoms.TTerm Query.Edge -> Phantoms.TTerm (Maybe Core.Name) -edgeOut x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.Edge"), - Core.projectionField = (Core.Name "out")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -edgeType :: Phantoms.TTerm Query.Edge -> Phantoms.TTerm Core.Name -edgeType x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.Edge"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -edgeWithIn :: Phantoms.TTerm Query.Edge -> Phantoms.TTerm (Maybe Core.Name) -> Phantoms.TTerm Query.Edge -edgeWithIn original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.query.Edge"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.Edge"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "out"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.Edge"), - Core.projectionField = (Core.Name "out")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "in"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -edgeWithOut :: Phantoms.TTerm Query.Edge -> Phantoms.TTerm (Maybe Core.Name) -> Phantoms.TTerm Query.Edge -edgeWithOut original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.query.Edge"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.Edge"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "out"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "in"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.Edge"), - Core.projectionField = (Core.Name "in")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -edgeWithType :: Phantoms.TTerm Query.Edge -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Query.Edge -edgeWithType original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.query.Edge"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "out"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.Edge"), - Core.projectionField = (Core.Name "out")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "in"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.Edge"), - Core.projectionField = (Core.Name "in")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -graphPattern :: Phantoms.TTerm Core.Name -> Phantoms.TTerm [Query.Pattern] -> Phantoms.TTerm Query.GraphPattern -graphPattern graph patterns = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.query.GraphPattern"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "graph"), - Core.fieldTerm = (Phantoms.unTTerm graph)}, - Core.Field { - Core.fieldName = (Core.Name "patterns"), - Core.fieldTerm = (Phantoms.unTTerm patterns)}]})) - -graphPatternGraph :: Phantoms.TTerm Query.GraphPattern -> Phantoms.TTerm Core.Name -graphPatternGraph x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.GraphPattern"), - Core.projectionField = (Core.Name "graph")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -graphPatternPatterns :: Phantoms.TTerm Query.GraphPattern -> Phantoms.TTerm [Query.Pattern] -graphPatternPatterns x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.GraphPattern"), - Core.projectionField = (Core.Name "patterns")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -graphPatternWithGraph :: Phantoms.TTerm Query.GraphPattern -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Query.GraphPattern -graphPatternWithGraph original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.query.GraphPattern"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "graph"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "patterns"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.GraphPattern"), - Core.projectionField = (Core.Name "patterns")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -graphPatternWithPatterns :: Phantoms.TTerm Query.GraphPattern -> Phantoms.TTerm [Query.Pattern] -> Phantoms.TTerm Query.GraphPattern -graphPatternWithPatterns original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.query.GraphPattern"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "graph"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.GraphPattern"), - Core.projectionField = (Core.Name "graph")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "patterns"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -nodeTerm :: Phantoms.TTerm Core.Term -> Phantoms.TTerm Query.Node -nodeTerm x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.Node"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -nodeVariable :: Phantoms.TTerm Query.Variable -> Phantoms.TTerm Query.Node -nodeVariable x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.Node"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "variable"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -nodeWildcard :: Phantoms.TTerm Query.Node -nodeWildcard = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.Node"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wildcard"), - Core.fieldTerm = Core.TermUnit}})) - -pathEquation :: Phantoms.TTerm Query.Path -> Phantoms.TTerm Query.Path -> Phantoms.TTerm Query.PathEquation -pathEquation left right = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.query.PathEquation"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "left"), - Core.fieldTerm = (Phantoms.unTTerm left)}, - Core.Field { - Core.fieldName = (Core.Name "right"), - Core.fieldTerm = (Phantoms.unTTerm right)}]})) - -pathEquationLeft :: Phantoms.TTerm Query.PathEquation -> Phantoms.TTerm Query.Path -pathEquationLeft x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.PathEquation"), - Core.projectionField = (Core.Name "left")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -pathEquationRight :: Phantoms.TTerm Query.PathEquation -> Phantoms.TTerm Query.Path -pathEquationRight x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.PathEquation"), - Core.projectionField = (Core.Name "right")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -pathEquationWithLeft :: Phantoms.TTerm Query.PathEquation -> Phantoms.TTerm Query.Path -> Phantoms.TTerm Query.PathEquation -pathEquationWithLeft original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.query.PathEquation"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "left"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "right"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.PathEquation"), - Core.projectionField = (Core.Name "right")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -pathEquationWithRight :: Phantoms.TTerm Query.PathEquation -> Phantoms.TTerm Query.Path -> Phantoms.TTerm Query.PathEquation -pathEquationWithRight original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.query.PathEquation"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "left"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.PathEquation"), - Core.projectionField = (Core.Name "left")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "right"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -pathInverse :: Phantoms.TTerm Query.Path -> Phantoms.TTerm Query.Path -pathInverse x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.Path"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inverse"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -pathRegex :: Phantoms.TTerm Query.RegexSequence -> Phantoms.TTerm Query.Path -pathRegex x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.Path"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "regex"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -pathStep :: Phantoms.TTerm Query.Step -> Phantoms.TTerm Query.Path -pathStep x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.Path"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "step"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -patternConjunction :: Phantoms.TTerm [Query.Pattern] -> Phantoms.TTerm Query.Pattern -patternConjunction x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.Pattern"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "conjunction"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -patternDisjunction :: Phantoms.TTerm [Query.Pattern] -> Phantoms.TTerm Query.Pattern -patternDisjunction x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.Pattern"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "disjunction"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -patternGraph :: Phantoms.TTerm Query.GraphPattern -> Phantoms.TTerm Query.Pattern -patternGraph x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.Pattern"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "graph"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -patternImplication :: Phantoms.TTerm Query.Pattern -> Phantoms.TTerm Query.Pattern -> Phantoms.TTerm Query.PatternImplication -patternImplication antecedent consequent = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.query.PatternImplication"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "antecedent"), - Core.fieldTerm = (Phantoms.unTTerm antecedent)}, - Core.Field { - Core.fieldName = (Core.Name "consequent"), - Core.fieldTerm = (Phantoms.unTTerm consequent)}]})) - -patternImplicationAntecedent :: Phantoms.TTerm Query.PatternImplication -> Phantoms.TTerm Query.Pattern -patternImplicationAntecedent x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.PatternImplication"), - Core.projectionField = (Core.Name "antecedent")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -patternImplicationConsequent :: Phantoms.TTerm Query.PatternImplication -> Phantoms.TTerm Query.Pattern -patternImplicationConsequent x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.PatternImplication"), - Core.projectionField = (Core.Name "consequent")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -patternImplicationWithAntecedent :: Phantoms.TTerm Query.PatternImplication -> Phantoms.TTerm Query.Pattern -> Phantoms.TTerm Query.PatternImplication -patternImplicationWithAntecedent original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.query.PatternImplication"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "antecedent"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "consequent"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.PatternImplication"), - Core.projectionField = (Core.Name "consequent")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -patternImplicationWithConsequent :: Phantoms.TTerm Query.PatternImplication -> Phantoms.TTerm Query.Pattern -> Phantoms.TTerm Query.PatternImplication -patternImplicationWithConsequent original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.query.PatternImplication"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "antecedent"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.PatternImplication"), - Core.projectionField = (Core.Name "antecedent")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "consequent"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -patternNegation :: Phantoms.TTerm Query.Pattern -> Phantoms.TTerm Query.Pattern -patternNegation x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.Pattern"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "negation"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -patternTriple :: Phantoms.TTerm Query.TriplePattern -> Phantoms.TTerm Query.Pattern -patternTriple x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.Pattern"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "triple"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -query :: Phantoms.TTerm [Query.Variable] -> Phantoms.TTerm [Query.Pattern] -> Phantoms.TTerm Query.Query -query variables patterns = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.query.Query"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "variables"), - Core.fieldTerm = (Phantoms.unTTerm variables)}, - Core.Field { - Core.fieldName = (Core.Name "patterns"), - Core.fieldTerm = (Phantoms.unTTerm patterns)}]})) - -queryPatterns :: Phantoms.TTerm Query.Query -> Phantoms.TTerm [Query.Pattern] -queryPatterns x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.Query"), - Core.projectionField = (Core.Name "patterns")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -queryVariables :: Phantoms.TTerm Query.Query -> Phantoms.TTerm [Query.Variable] -queryVariables x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.Query"), - Core.projectionField = (Core.Name "variables")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -queryWithPatterns :: Phantoms.TTerm Query.Query -> Phantoms.TTerm [Query.Pattern] -> Phantoms.TTerm Query.Query -queryWithPatterns original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.query.Query"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "variables"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.Query"), - Core.projectionField = (Core.Name "variables")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "patterns"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -queryWithVariables :: Phantoms.TTerm Query.Query -> Phantoms.TTerm [Query.Variable] -> Phantoms.TTerm Query.Query -queryWithVariables original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.query.Query"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "variables"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "patterns"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.Query"), - Core.projectionField = (Core.Name "patterns")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -range :: Phantoms.TTerm Int -> Phantoms.TTerm Int -> Phantoms.TTerm Query.Range -range min max = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.query.Range"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "min"), - Core.fieldTerm = (Phantoms.unTTerm min)}, - Core.Field { - Core.fieldName = (Core.Name "max"), - Core.fieldTerm = (Phantoms.unTTerm max)}]})) - -rangeMax :: Phantoms.TTerm Query.Range -> Phantoms.TTerm Int -rangeMax x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.Range"), - Core.projectionField = (Core.Name "max")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -rangeMin :: Phantoms.TTerm Query.Range -> Phantoms.TTerm Int -rangeMin x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.Range"), - Core.projectionField = (Core.Name "min")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -rangeWithMax :: Phantoms.TTerm Query.Range -> Phantoms.TTerm Int -> Phantoms.TTerm Query.Range -rangeWithMax original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.query.Range"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "min"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.Range"), - Core.projectionField = (Core.Name "min")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "max"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -rangeWithMin :: Phantoms.TTerm Query.Range -> Phantoms.TTerm Int -> Phantoms.TTerm Query.Range -rangeWithMin original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.query.Range"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "min"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "max"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.Range"), - Core.projectionField = (Core.Name "max")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -regexQuantifierAtLeast :: Phantoms.TTerm Int -> Phantoms.TTerm Query.RegexQuantifier -regexQuantifierAtLeast x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.RegexQuantifier"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "atLeast"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -regexQuantifierExactly :: Phantoms.TTerm Int -> Phantoms.TTerm Query.RegexQuantifier -regexQuantifierExactly x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.RegexQuantifier"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "exactly"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -regexQuantifierOne :: Phantoms.TTerm Query.RegexQuantifier -regexQuantifierOne = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.RegexQuantifier"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "one"), - Core.fieldTerm = Core.TermUnit}})) - -regexQuantifierOneOrMore :: Phantoms.TTerm Query.RegexQuantifier -regexQuantifierOneOrMore = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.RegexQuantifier"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "oneOrMore"), - Core.fieldTerm = Core.TermUnit}})) - -regexQuantifierRange :: Phantoms.TTerm Query.Range -> Phantoms.TTerm Query.RegexQuantifier -regexQuantifierRange x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.RegexQuantifier"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "range"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -regexQuantifierZeroOrMore :: Phantoms.TTerm Query.RegexQuantifier -regexQuantifierZeroOrMore = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.RegexQuantifier"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "zeroOrMore"), - Core.fieldTerm = Core.TermUnit}})) - -regexQuantifierZeroOrOne :: Phantoms.TTerm Query.RegexQuantifier -regexQuantifierZeroOrOne = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.RegexQuantifier"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "zeroOrOne"), - Core.fieldTerm = Core.TermUnit}})) - -regexSequence :: Phantoms.TTerm Query.Path -> Phantoms.TTerm Query.RegexQuantifier -> Phantoms.TTerm Query.RegexSequence -regexSequence path quantifier = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.query.RegexSequence"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "path"), - Core.fieldTerm = (Phantoms.unTTerm path)}, - Core.Field { - Core.fieldName = (Core.Name "quantifier"), - Core.fieldTerm = (Phantoms.unTTerm quantifier)}]})) - -regexSequencePath :: Phantoms.TTerm Query.RegexSequence -> Phantoms.TTerm Query.Path -regexSequencePath x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.RegexSequence"), - Core.projectionField = (Core.Name "path")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -regexSequenceQuantifier :: Phantoms.TTerm Query.RegexSequence -> Phantoms.TTerm Query.RegexQuantifier -regexSequenceQuantifier x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.RegexSequence"), - Core.projectionField = (Core.Name "quantifier")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -regexSequenceWithPath :: Phantoms.TTerm Query.RegexSequence -> Phantoms.TTerm Query.Path -> Phantoms.TTerm Query.RegexSequence -regexSequenceWithPath original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.query.RegexSequence"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "path"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "quantifier"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.RegexSequence"), - Core.projectionField = (Core.Name "quantifier")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -regexSequenceWithQuantifier :: Phantoms.TTerm Query.RegexSequence -> Phantoms.TTerm Query.RegexQuantifier -> Phantoms.TTerm Query.RegexSequence -regexSequenceWithQuantifier original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.query.RegexSequence"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "path"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.RegexSequence"), - Core.projectionField = (Core.Name "path")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "quantifier"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -stepCompare :: Phantoms.TTerm Query.ComparisonConstraint -> Phantoms.TTerm Query.Step -stepCompare x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.Step"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "compare"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -stepEdge :: Phantoms.TTerm Query.Edge -> Phantoms.TTerm Query.Step -stepEdge x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.Step"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "edge"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -stepProject :: Phantoms.TTerm Core.Projection -> Phantoms.TTerm Query.Step -stepProject x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.Step"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "project"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -triplePattern :: Phantoms.TTerm Query.Node -> Phantoms.TTerm Query.Path -> Phantoms.TTerm Query.Node -> Phantoms.TTerm Query.TriplePattern -triplePattern subject predicate object = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.query.TriplePattern"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "subject"), - Core.fieldTerm = (Phantoms.unTTerm subject)}, - Core.Field { - Core.fieldName = (Core.Name "predicate"), - Core.fieldTerm = (Phantoms.unTTerm predicate)}, - Core.Field { - Core.fieldName = (Core.Name "object"), - Core.fieldTerm = (Phantoms.unTTerm object)}]})) - -triplePatternObject :: Phantoms.TTerm Query.TriplePattern -> Phantoms.TTerm Query.Node -triplePatternObject x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.TriplePattern"), - Core.projectionField = (Core.Name "object")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -triplePatternPredicate :: Phantoms.TTerm Query.TriplePattern -> Phantoms.TTerm Query.Path -triplePatternPredicate x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.TriplePattern"), - Core.projectionField = (Core.Name "predicate")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -triplePatternSubject :: Phantoms.TTerm Query.TriplePattern -> Phantoms.TTerm Query.Node -triplePatternSubject x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.TriplePattern"), - Core.projectionField = (Core.Name "subject")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -triplePatternWithObject :: Phantoms.TTerm Query.TriplePattern -> Phantoms.TTerm Query.Node -> Phantoms.TTerm Query.TriplePattern -triplePatternWithObject original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.query.TriplePattern"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "subject"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.TriplePattern"), - Core.projectionField = (Core.Name "subject")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "predicate"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.TriplePattern"), - Core.projectionField = (Core.Name "predicate")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "object"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -triplePatternWithPredicate :: Phantoms.TTerm Query.TriplePattern -> Phantoms.TTerm Query.Path -> Phantoms.TTerm Query.TriplePattern -triplePatternWithPredicate original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.query.TriplePattern"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "subject"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.TriplePattern"), - Core.projectionField = (Core.Name "subject")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "predicate"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "object"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.TriplePattern"), - Core.projectionField = (Core.Name "object")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -triplePatternWithSubject :: Phantoms.TTerm Query.TriplePattern -> Phantoms.TTerm Query.Node -> Phantoms.TTerm Query.TriplePattern -triplePatternWithSubject original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.query.TriplePattern"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "subject"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "predicate"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.TriplePattern"), - Core.projectionField = (Core.Name "predicate")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "object"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.query.TriplePattern"), - Core.projectionField = (Core.Name "object")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -unVariable :: Phantoms.TTerm Query.Variable -> Phantoms.TTerm String -unVariable x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.query.Variable")))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -variable :: Phantoms.TTerm String -> Phantoms.TTerm Query.Variable -variable x = - Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.query.Variable"), - Core.wrappedTermBody = (Phantoms.unTTerm x)})) diff --git a/src/gen-main/haskell/Hydra/Dsl/Relational.hs b/src/gen-main/haskell/Hydra/Dsl/Relational.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Dsl/Relational.hs +++ /dev/null @@ -1,377 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | DSL functions for hydra.relational - -module Hydra.Dsl.Relational where - -import qualified Hydra.Core as Core -import qualified Hydra.Phantoms as Phantoms -import qualified Hydra.Relational as Relational -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -columnName :: Phantoms.TTerm String -> Phantoms.TTerm Relational.ColumnName -columnName x = - Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.relational.ColumnName"), - Core.wrappedTermBody = (Phantoms.unTTerm x)})) - -columnSchema :: Phantoms.TTerm Relational.ColumnName -> Phantoms.TTerm t -> Phantoms.TTerm (Relational.ColumnSchema t) -columnSchema name domain = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.relational.ColumnSchema"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm name)}, - Core.Field { - Core.fieldName = (Core.Name "domain"), - Core.fieldTerm = (Phantoms.unTTerm domain)}]})) - -columnSchemaDomain :: Phantoms.TTerm (Relational.ColumnSchema t) -> Phantoms.TTerm t -columnSchemaDomain x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.relational.ColumnSchema"), - Core.projectionField = (Core.Name "domain")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -columnSchemaName :: Phantoms.TTerm (Relational.ColumnSchema t) -> Phantoms.TTerm Relational.ColumnName -columnSchemaName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.relational.ColumnSchema"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -columnSchemaWithDomain :: Phantoms.TTerm (Relational.ColumnSchema t) -> Phantoms.TTerm t -> Phantoms.TTerm (Relational.ColumnSchema t) -columnSchemaWithDomain original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.relational.ColumnSchema"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.relational.ColumnSchema"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "domain"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -columnSchemaWithName :: Phantoms.TTerm (Relational.ColumnSchema t) -> Phantoms.TTerm Relational.ColumnName -> Phantoms.TTerm (Relational.ColumnSchema t) -columnSchemaWithName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.relational.ColumnSchema"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "domain"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.relational.ColumnSchema"), - Core.projectionField = (Core.Name "domain")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -foreignKey :: Phantoms.TTerm Relational.RelationName -> Phantoms.TTerm (M.Map Relational.ColumnName Relational.ColumnName) -> Phantoms.TTerm Relational.ForeignKey -foreignKey foreignRelation keys = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.relational.ForeignKey"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "foreignRelation"), - Core.fieldTerm = (Phantoms.unTTerm foreignRelation)}, - Core.Field { - Core.fieldName = (Core.Name "keys"), - Core.fieldTerm = (Phantoms.unTTerm keys)}]})) - -foreignKeyForeignRelation :: Phantoms.TTerm Relational.ForeignKey -> Phantoms.TTerm Relational.RelationName -foreignKeyForeignRelation x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.relational.ForeignKey"), - Core.projectionField = (Core.Name "foreignRelation")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -foreignKeyKeys :: Phantoms.TTerm Relational.ForeignKey -> Phantoms.TTerm (M.Map Relational.ColumnName Relational.ColumnName) -foreignKeyKeys x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.relational.ForeignKey"), - Core.projectionField = (Core.Name "keys")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -foreignKeyWithForeignRelation :: Phantoms.TTerm Relational.ForeignKey -> Phantoms.TTerm Relational.RelationName -> Phantoms.TTerm Relational.ForeignKey -foreignKeyWithForeignRelation original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.relational.ForeignKey"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "foreignRelation"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "keys"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.relational.ForeignKey"), - Core.projectionField = (Core.Name "keys")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -foreignKeyWithKeys :: Phantoms.TTerm Relational.ForeignKey -> Phantoms.TTerm (M.Map Relational.ColumnName Relational.ColumnName) -> Phantoms.TTerm Relational.ForeignKey -foreignKeyWithKeys original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.relational.ForeignKey"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "foreignRelation"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.relational.ForeignKey"), - Core.projectionField = (Core.Name "foreignRelation")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "keys"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -primaryKey :: Phantoms.TTerm [Relational.ColumnName] -> Phantoms.TTerm Relational.PrimaryKey -primaryKey x = - Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.relational.PrimaryKey"), - Core.wrappedTermBody = (Phantoms.unTTerm x)})) - -relation :: Phantoms.TTerm [Relational.Row v] -> Phantoms.TTerm (Relational.Relation v) -relation x = - Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.relational.Relation"), - Core.wrappedTermBody = (Phantoms.unTTerm x)})) - -relationName :: Phantoms.TTerm String -> Phantoms.TTerm Relational.RelationName -relationName x = - Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.relational.RelationName"), - Core.wrappedTermBody = (Phantoms.unTTerm x)})) - -relationSchema :: Phantoms.TTerm Relational.RelationName -> Phantoms.TTerm [Relational.ColumnSchema t] -> Phantoms.TTerm [Relational.PrimaryKey] -> Phantoms.TTerm [Relational.ForeignKey] -> Phantoms.TTerm (Relational.RelationSchema t) -relationSchema name columns primaryKeys foreignKeys = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.relational.RelationSchema"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm name)}, - Core.Field { - Core.fieldName = (Core.Name "columns"), - Core.fieldTerm = (Phantoms.unTTerm columns)}, - Core.Field { - Core.fieldName = (Core.Name "primaryKeys"), - Core.fieldTerm = (Phantoms.unTTerm primaryKeys)}, - Core.Field { - Core.fieldName = (Core.Name "foreignKeys"), - Core.fieldTerm = (Phantoms.unTTerm foreignKeys)}]})) - -relationSchemaColumns :: Phantoms.TTerm (Relational.RelationSchema t) -> Phantoms.TTerm [Relational.ColumnSchema t] -relationSchemaColumns x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.relational.RelationSchema"), - Core.projectionField = (Core.Name "columns")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -relationSchemaForeignKeys :: Phantoms.TTerm (Relational.RelationSchema t) -> Phantoms.TTerm [Relational.ForeignKey] -relationSchemaForeignKeys x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.relational.RelationSchema"), - Core.projectionField = (Core.Name "foreignKeys")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -relationSchemaName :: Phantoms.TTerm (Relational.RelationSchema t) -> Phantoms.TTerm Relational.RelationName -relationSchemaName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.relational.RelationSchema"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -relationSchemaPrimaryKeys :: Phantoms.TTerm (Relational.RelationSchema t) -> Phantoms.TTerm [Relational.PrimaryKey] -relationSchemaPrimaryKeys x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.relational.RelationSchema"), - Core.projectionField = (Core.Name "primaryKeys")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -relationSchemaWithColumns :: Phantoms.TTerm (Relational.RelationSchema t) -> Phantoms.TTerm [Relational.ColumnSchema t] -> Phantoms.TTerm (Relational.RelationSchema t) -relationSchemaWithColumns original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.relational.RelationSchema"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.relational.RelationSchema"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "columns"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "primaryKeys"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.relational.RelationSchema"), - Core.projectionField = (Core.Name "primaryKeys")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "foreignKeys"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.relational.RelationSchema"), - Core.projectionField = (Core.Name "foreignKeys")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -relationSchemaWithForeignKeys :: Phantoms.TTerm (Relational.RelationSchema t) -> Phantoms.TTerm [Relational.ForeignKey] -> Phantoms.TTerm (Relational.RelationSchema t) -relationSchemaWithForeignKeys original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.relational.RelationSchema"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.relational.RelationSchema"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "columns"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.relational.RelationSchema"), - Core.projectionField = (Core.Name "columns")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "primaryKeys"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.relational.RelationSchema"), - Core.projectionField = (Core.Name "primaryKeys")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "foreignKeys"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -relationSchemaWithName :: Phantoms.TTerm (Relational.RelationSchema t) -> Phantoms.TTerm Relational.RelationName -> Phantoms.TTerm (Relational.RelationSchema t) -relationSchemaWithName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.relational.RelationSchema"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "columns"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.relational.RelationSchema"), - Core.projectionField = (Core.Name "columns")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "primaryKeys"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.relational.RelationSchema"), - Core.projectionField = (Core.Name "primaryKeys")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "foreignKeys"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.relational.RelationSchema"), - Core.projectionField = (Core.Name "foreignKeys")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -relationSchemaWithPrimaryKeys :: Phantoms.TTerm (Relational.RelationSchema t) -> Phantoms.TTerm [Relational.PrimaryKey] -> Phantoms.TTerm (Relational.RelationSchema t) -relationSchemaWithPrimaryKeys original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.relational.RelationSchema"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.relational.RelationSchema"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "columns"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.relational.RelationSchema"), - Core.projectionField = (Core.Name "columns")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "primaryKeys"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "foreignKeys"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.relational.RelationSchema"), - Core.projectionField = (Core.Name "foreignKeys")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -relationship :: Phantoms.TTerm (S.Set (M.Map Relational.ColumnName v)) -> Phantoms.TTerm (Relational.Relationship v) -relationship x = - Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.relational.Relationship"), - Core.wrappedTermBody = (Phantoms.unTTerm x)})) - -row :: Phantoms.TTerm [v] -> Phantoms.TTerm (Relational.Row v) -row x = - Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.relational.Row"), - Core.wrappedTermBody = (Phantoms.unTTerm x)})) - -unColumnName :: Phantoms.TTerm Relational.ColumnName -> Phantoms.TTerm String -unColumnName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.relational.ColumnName")))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -unPrimaryKey :: Phantoms.TTerm Relational.PrimaryKey -> Phantoms.TTerm [Relational.ColumnName] -unPrimaryKey x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.relational.PrimaryKey")))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -unRelation :: Phantoms.TTerm (Relational.Relation v) -> Phantoms.TTerm [Relational.Row v] -unRelation x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.relational.Relation")))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -unRelationName :: Phantoms.TTerm Relational.RelationName -> Phantoms.TTerm String -unRelationName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.relational.RelationName")))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -unRelationship :: Phantoms.TTerm (Relational.Relationship v) -> Phantoms.TTerm (S.Set (M.Map Relational.ColumnName v)) -unRelationship x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.relational.Relationship")))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -unRow :: Phantoms.TTerm (Relational.Row v) -> Phantoms.TTerm [v] -unRow x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.relational.Row")))), - Core.applicationArgument = (Phantoms.unTTerm x)})) diff --git a/src/gen-main/haskell/Hydra/Dsl/Tabular.hs b/src/gen-main/haskell/Hydra/Dsl/Tabular.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Dsl/Tabular.hs +++ /dev/null @@ -1,220 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | DSL functions for hydra.tabular - -module Hydra.Dsl.Tabular where - -import qualified Hydra.Core as Core -import qualified Hydra.Phantoms as Phantoms -import qualified Hydra.Relational as Relational -import qualified Hydra.Tabular as Tabular -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -columnType :: Phantoms.TTerm Relational.ColumnName -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Tabular.ColumnType -columnType name type_ = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.tabular.ColumnType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm name)}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Phantoms.unTTerm type_)}]})) - -columnTypeName :: Phantoms.TTerm Tabular.ColumnType -> Phantoms.TTerm Relational.ColumnName -columnTypeName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.tabular.ColumnType"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -columnTypeType :: Phantoms.TTerm Tabular.ColumnType -> Phantoms.TTerm Core.Type -columnTypeType x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.tabular.ColumnType"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -columnTypeWithName :: Phantoms.TTerm Tabular.ColumnType -> Phantoms.TTerm Relational.ColumnName -> Phantoms.TTerm Tabular.ColumnType -columnTypeWithName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.tabular.ColumnType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.tabular.ColumnType"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -columnTypeWithType :: Phantoms.TTerm Tabular.ColumnType -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Tabular.ColumnType -columnTypeWithType original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.tabular.ColumnType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.tabular.ColumnType"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -dataRow :: Phantoms.TTerm [Maybe v] -> Phantoms.TTerm (Tabular.DataRow v) -dataRow x = - Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.tabular.DataRow"), - Core.wrappedTermBody = (Phantoms.unTTerm x)})) - -headerRow :: Phantoms.TTerm [String] -> Phantoms.TTerm Tabular.HeaderRow -headerRow x = - Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.tabular.HeaderRow"), - Core.wrappedTermBody = (Phantoms.unTTerm x)})) - -table :: Phantoms.TTerm (Maybe Tabular.HeaderRow) -> Phantoms.TTerm [Tabular.DataRow v] -> Phantoms.TTerm (Tabular.Table v) -table header data_ = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.tabular.Table"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "header"), - Core.fieldTerm = (Phantoms.unTTerm header)}, - Core.Field { - Core.fieldName = (Core.Name "data"), - Core.fieldTerm = (Phantoms.unTTerm data_)}]})) - -tableData :: Phantoms.TTerm (Tabular.Table v) -> Phantoms.TTerm [Tabular.DataRow v] -tableData x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.tabular.Table"), - Core.projectionField = (Core.Name "data")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -tableHeader :: Phantoms.TTerm (Tabular.Table v) -> Phantoms.TTerm (Maybe Tabular.HeaderRow) -tableHeader x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.tabular.Table"), - Core.projectionField = (Core.Name "header")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -tableType :: Phantoms.TTerm Relational.RelationName -> Phantoms.TTerm [Tabular.ColumnType] -> Phantoms.TTerm Tabular.TableType -tableType name columns = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.tabular.TableType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm name)}, - Core.Field { - Core.fieldName = (Core.Name "columns"), - Core.fieldTerm = (Phantoms.unTTerm columns)}]})) - -tableTypeColumns :: Phantoms.TTerm Tabular.TableType -> Phantoms.TTerm [Tabular.ColumnType] -tableTypeColumns x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.tabular.TableType"), - Core.projectionField = (Core.Name "columns")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -tableTypeName :: Phantoms.TTerm Tabular.TableType -> Phantoms.TTerm Relational.RelationName -tableTypeName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.tabular.TableType"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -tableTypeWithColumns :: Phantoms.TTerm Tabular.TableType -> Phantoms.TTerm [Tabular.ColumnType] -> Phantoms.TTerm Tabular.TableType -tableTypeWithColumns original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.tabular.TableType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.tabular.TableType"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "columns"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -tableTypeWithName :: Phantoms.TTerm Tabular.TableType -> Phantoms.TTerm Relational.RelationName -> Phantoms.TTerm Tabular.TableType -tableTypeWithName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.tabular.TableType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "columns"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.tabular.TableType"), - Core.projectionField = (Core.Name "columns")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -tableWithData :: Phantoms.TTerm (Tabular.Table v) -> Phantoms.TTerm [Tabular.DataRow v] -> Phantoms.TTerm (Tabular.Table v) -tableWithData original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.tabular.Table"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "header"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.tabular.Table"), - Core.projectionField = (Core.Name "header")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "data"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -tableWithHeader :: Phantoms.TTerm (Tabular.Table v) -> Phantoms.TTerm (Maybe Tabular.HeaderRow) -> Phantoms.TTerm (Tabular.Table v) -tableWithHeader original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.tabular.Table"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "header"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "data"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.tabular.Table"), - Core.projectionField = (Core.Name "data")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -unDataRow :: Phantoms.TTerm (Tabular.DataRow v) -> Phantoms.TTerm [Maybe v] -unDataRow x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.tabular.DataRow")))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -unHeaderRow :: Phantoms.TTerm Tabular.HeaderRow -> Phantoms.TTerm [String] -unHeaderRow x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.tabular.HeaderRow")))), - Core.applicationArgument = (Phantoms.unTTerm x)})) diff --git a/src/gen-main/haskell/Hydra/Dsl/Testing.hs b/src/gen-main/haskell/Hydra/Dsl/Testing.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Dsl/Testing.hs +++ /dev/null @@ -1,5142 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | DSL functions for hydra.testing - -module Hydra.Dsl.Testing where - -import qualified Hydra.Ast as Ast -import qualified Hydra.Coders as Coders -import qualified Hydra.Core as Core -import qualified Hydra.Error.Core as Core_ -import qualified Hydra.Graph as Graph -import qualified Hydra.Json.Model as Model -import qualified Hydra.Module as Module -import qualified Hydra.Parsing as Parsing -import qualified Hydra.Phantoms as Phantoms -import qualified Hydra.Testing as Testing -import qualified Hydra.Typing as Typing -import qualified Hydra.Util as Util -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -alphaConversionTestCase :: Phantoms.TTerm Core.Term -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Testing.AlphaConversionTestCase -alphaConversionTestCase term oldVariable newVariable result = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.AlphaConversionTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Phantoms.unTTerm term)}, - Core.Field { - Core.fieldName = (Core.Name "oldVariable"), - Core.fieldTerm = (Phantoms.unTTerm oldVariable)}, - Core.Field { - Core.fieldName = (Core.Name "newVariable"), - Core.fieldTerm = (Phantoms.unTTerm newVariable)}, - Core.Field { - Core.fieldName = (Core.Name "result"), - Core.fieldTerm = (Phantoms.unTTerm result)}]})) - -alphaConversionTestCaseNewVariable :: Phantoms.TTerm Testing.AlphaConversionTestCase -> Phantoms.TTerm Core.Name -alphaConversionTestCaseNewVariable x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.AlphaConversionTestCase"), - Core.projectionField = (Core.Name "newVariable")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -alphaConversionTestCaseOldVariable :: Phantoms.TTerm Testing.AlphaConversionTestCase -> Phantoms.TTerm Core.Name -alphaConversionTestCaseOldVariable x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.AlphaConversionTestCase"), - Core.projectionField = (Core.Name "oldVariable")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -alphaConversionTestCaseResult :: Phantoms.TTerm Testing.AlphaConversionTestCase -> Phantoms.TTerm Core.Term -alphaConversionTestCaseResult x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.AlphaConversionTestCase"), - Core.projectionField = (Core.Name "result")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -alphaConversionTestCaseTerm :: Phantoms.TTerm Testing.AlphaConversionTestCase -> Phantoms.TTerm Core.Term -alphaConversionTestCaseTerm x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.AlphaConversionTestCase"), - Core.projectionField = (Core.Name "term")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -alphaConversionTestCaseWithNewVariable :: Phantoms.TTerm Testing.AlphaConversionTestCase -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Testing.AlphaConversionTestCase -alphaConversionTestCaseWithNewVariable original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.AlphaConversionTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.AlphaConversionTestCase"), - Core.projectionField = (Core.Name "term")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "oldVariable"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.AlphaConversionTestCase"), - Core.projectionField = (Core.Name "oldVariable")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "newVariable"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "result"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.AlphaConversionTestCase"), - Core.projectionField = (Core.Name "result")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -alphaConversionTestCaseWithOldVariable :: Phantoms.TTerm Testing.AlphaConversionTestCase -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Testing.AlphaConversionTestCase -alphaConversionTestCaseWithOldVariable original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.AlphaConversionTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.AlphaConversionTestCase"), - Core.projectionField = (Core.Name "term")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "oldVariable"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "newVariable"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.AlphaConversionTestCase"), - Core.projectionField = (Core.Name "newVariable")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "result"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.AlphaConversionTestCase"), - Core.projectionField = (Core.Name "result")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -alphaConversionTestCaseWithResult :: Phantoms.TTerm Testing.AlphaConversionTestCase -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Testing.AlphaConversionTestCase -alphaConversionTestCaseWithResult original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.AlphaConversionTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.AlphaConversionTestCase"), - Core.projectionField = (Core.Name "term")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "oldVariable"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.AlphaConversionTestCase"), - Core.projectionField = (Core.Name "oldVariable")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "newVariable"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.AlphaConversionTestCase"), - Core.projectionField = (Core.Name "newVariable")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "result"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -alphaConversionTestCaseWithTerm :: Phantoms.TTerm Testing.AlphaConversionTestCase -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Testing.AlphaConversionTestCase -alphaConversionTestCaseWithTerm original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.AlphaConversionTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "oldVariable"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.AlphaConversionTestCase"), - Core.projectionField = (Core.Name "oldVariable")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "newVariable"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.AlphaConversionTestCase"), - Core.projectionField = (Core.Name "newVariable")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "result"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.AlphaConversionTestCase"), - Core.projectionField = (Core.Name "result")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -caseConversionTestCase :: Phantoms.TTerm Util.CaseConvention -> Phantoms.TTerm Util.CaseConvention -> Phantoms.TTerm String -> Phantoms.TTerm String -> Phantoms.TTerm Testing.CaseConversionTestCase -caseConversionTestCase fromConvention toConvention fromString toString = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.CaseConversionTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "fromConvention"), - Core.fieldTerm = (Phantoms.unTTerm fromConvention)}, - Core.Field { - Core.fieldName = (Core.Name "toConvention"), - Core.fieldTerm = (Phantoms.unTTerm toConvention)}, - Core.Field { - Core.fieldName = (Core.Name "fromString"), - Core.fieldTerm = (Phantoms.unTTerm fromString)}, - Core.Field { - Core.fieldName = (Core.Name "toString"), - Core.fieldTerm = (Phantoms.unTTerm toString)}]})) - -caseConversionTestCaseFromConvention :: Phantoms.TTerm Testing.CaseConversionTestCase -> Phantoms.TTerm Util.CaseConvention -caseConversionTestCaseFromConvention x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.CaseConversionTestCase"), - Core.projectionField = (Core.Name "fromConvention")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -caseConversionTestCaseFromString :: Phantoms.TTerm Testing.CaseConversionTestCase -> Phantoms.TTerm String -caseConversionTestCaseFromString x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.CaseConversionTestCase"), - Core.projectionField = (Core.Name "fromString")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -caseConversionTestCaseToConvention :: Phantoms.TTerm Testing.CaseConversionTestCase -> Phantoms.TTerm Util.CaseConvention -caseConversionTestCaseToConvention x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.CaseConversionTestCase"), - Core.projectionField = (Core.Name "toConvention")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -caseConversionTestCaseToString :: Phantoms.TTerm Testing.CaseConversionTestCase -> Phantoms.TTerm String -caseConversionTestCaseToString x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.CaseConversionTestCase"), - Core.projectionField = (Core.Name "toString")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -caseConversionTestCaseWithFromConvention :: Phantoms.TTerm Testing.CaseConversionTestCase -> Phantoms.TTerm Util.CaseConvention -> Phantoms.TTerm Testing.CaseConversionTestCase -caseConversionTestCaseWithFromConvention original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.CaseConversionTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "fromConvention"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "toConvention"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.CaseConversionTestCase"), - Core.projectionField = (Core.Name "toConvention")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "fromString"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.CaseConversionTestCase"), - Core.projectionField = (Core.Name "fromString")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "toString"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.CaseConversionTestCase"), - Core.projectionField = (Core.Name "toString")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -caseConversionTestCaseWithFromString :: Phantoms.TTerm Testing.CaseConversionTestCase -> Phantoms.TTerm String -> Phantoms.TTerm Testing.CaseConversionTestCase -caseConversionTestCaseWithFromString original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.CaseConversionTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "fromConvention"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.CaseConversionTestCase"), - Core.projectionField = (Core.Name "fromConvention")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "toConvention"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.CaseConversionTestCase"), - Core.projectionField = (Core.Name "toConvention")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "fromString"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "toString"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.CaseConversionTestCase"), - Core.projectionField = (Core.Name "toString")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -caseConversionTestCaseWithToConvention :: Phantoms.TTerm Testing.CaseConversionTestCase -> Phantoms.TTerm Util.CaseConvention -> Phantoms.TTerm Testing.CaseConversionTestCase -caseConversionTestCaseWithToConvention original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.CaseConversionTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "fromConvention"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.CaseConversionTestCase"), - Core.projectionField = (Core.Name "fromConvention")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "toConvention"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "fromString"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.CaseConversionTestCase"), - Core.projectionField = (Core.Name "fromString")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "toString"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.CaseConversionTestCase"), - Core.projectionField = (Core.Name "toString")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -caseConversionTestCaseWithToString :: Phantoms.TTerm Testing.CaseConversionTestCase -> Phantoms.TTerm String -> Phantoms.TTerm Testing.CaseConversionTestCase -caseConversionTestCaseWithToString original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.CaseConversionTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "fromConvention"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.CaseConversionTestCase"), - Core.projectionField = (Core.Name "fromConvention")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "toConvention"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.CaseConversionTestCase"), - Core.projectionField = (Core.Name "toConvention")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "fromString"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.CaseConversionTestCase"), - Core.projectionField = (Core.Name "fromString")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "toString"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -deannotateTermTestCase :: Phantoms.TTerm Core.Term -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Testing.DeannotateTermTestCase -deannotateTermTestCase input output = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.DeannotateTermTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Phantoms.unTTerm input)}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Phantoms.unTTerm output)}]})) - -deannotateTermTestCaseInput :: Phantoms.TTerm Testing.DeannotateTermTestCase -> Phantoms.TTerm Core.Term -deannotateTermTestCaseInput x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.DeannotateTermTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -deannotateTermTestCaseOutput :: Phantoms.TTerm Testing.DeannotateTermTestCase -> Phantoms.TTerm Core.Term -deannotateTermTestCaseOutput x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.DeannotateTermTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -deannotateTermTestCaseWithInput :: Phantoms.TTerm Testing.DeannotateTermTestCase -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Testing.DeannotateTermTestCase -deannotateTermTestCaseWithInput original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.DeannotateTermTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.DeannotateTermTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -deannotateTermTestCaseWithOutput :: Phantoms.TTerm Testing.DeannotateTermTestCase -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Testing.DeannotateTermTestCase -deannotateTermTestCaseWithOutput original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.DeannotateTermTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.DeannotateTermTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -deannotateTypeTestCase :: Phantoms.TTerm Core.Type -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Testing.DeannotateTypeTestCase -deannotateTypeTestCase input output = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.DeannotateTypeTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Phantoms.unTTerm input)}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Phantoms.unTTerm output)}]})) - -deannotateTypeTestCaseInput :: Phantoms.TTerm Testing.DeannotateTypeTestCase -> Phantoms.TTerm Core.Type -deannotateTypeTestCaseInput x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.DeannotateTypeTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -deannotateTypeTestCaseOutput :: Phantoms.TTerm Testing.DeannotateTypeTestCase -> Phantoms.TTerm Core.Type -deannotateTypeTestCaseOutput x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.DeannotateTypeTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -deannotateTypeTestCaseWithInput :: Phantoms.TTerm Testing.DeannotateTypeTestCase -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Testing.DeannotateTypeTestCase -deannotateTypeTestCaseWithInput original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.DeannotateTypeTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.DeannotateTypeTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -deannotateTypeTestCaseWithOutput :: Phantoms.TTerm Testing.DeannotateTypeTestCase -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Testing.DeannotateTypeTestCase -deannotateTypeTestCaseWithOutput original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.DeannotateTypeTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.DeannotateTypeTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -delegatedEvaluationTestCase :: Phantoms.TTerm Core.Term -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Testing.DelegatedEvaluationTestCase -delegatedEvaluationTestCase input output = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.DelegatedEvaluationTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Phantoms.unTTerm input)}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Phantoms.unTTerm output)}]})) - -delegatedEvaluationTestCaseInput :: Phantoms.TTerm Testing.DelegatedEvaluationTestCase -> Phantoms.TTerm Core.Term -delegatedEvaluationTestCaseInput x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.DelegatedEvaluationTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -delegatedEvaluationTestCaseOutput :: Phantoms.TTerm Testing.DelegatedEvaluationTestCase -> Phantoms.TTerm Core.Term -delegatedEvaluationTestCaseOutput x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.DelegatedEvaluationTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -delegatedEvaluationTestCaseWithInput :: Phantoms.TTerm Testing.DelegatedEvaluationTestCase -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Testing.DelegatedEvaluationTestCase -delegatedEvaluationTestCaseWithInput original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.DelegatedEvaluationTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.DelegatedEvaluationTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -delegatedEvaluationTestCaseWithOutput :: Phantoms.TTerm Testing.DelegatedEvaluationTestCase -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Testing.DelegatedEvaluationTestCase -delegatedEvaluationTestCaseWithOutput original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.DelegatedEvaluationTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.DelegatedEvaluationTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -etaExpansionTestCase :: Phantoms.TTerm Core.Term -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Testing.EtaExpansionTestCase -etaExpansionTestCase input output = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.EtaExpansionTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Phantoms.unTTerm input)}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Phantoms.unTTerm output)}]})) - -etaExpansionTestCaseInput :: Phantoms.TTerm Testing.EtaExpansionTestCase -> Phantoms.TTerm Core.Term -etaExpansionTestCaseInput x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.EtaExpansionTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -etaExpansionTestCaseOutput :: Phantoms.TTerm Testing.EtaExpansionTestCase -> Phantoms.TTerm Core.Term -etaExpansionTestCaseOutput x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.EtaExpansionTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -etaExpansionTestCaseWithInput :: Phantoms.TTerm Testing.EtaExpansionTestCase -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Testing.EtaExpansionTestCase -etaExpansionTestCaseWithInput original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.EtaExpansionTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.EtaExpansionTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -etaExpansionTestCaseWithOutput :: Phantoms.TTerm Testing.EtaExpansionTestCase -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Testing.EtaExpansionTestCase -etaExpansionTestCaseWithOutput original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.EtaExpansionTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.EtaExpansionTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -evaluationStyleEager :: Phantoms.TTerm Testing.EvaluationStyle -evaluationStyleEager = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.EvaluationStyle"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "eager"), - Core.fieldTerm = Core.TermUnit}})) - -evaluationStyleLazy :: Phantoms.TTerm Testing.EvaluationStyle -evaluationStyleLazy = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.EvaluationStyle"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "lazy"), - Core.fieldTerm = Core.TermUnit}})) - -evaluationTestCase :: Phantoms.TTerm Testing.EvaluationStyle -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Testing.EvaluationTestCase -evaluationTestCase evaluationStyle input output = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.EvaluationTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "evaluationStyle"), - Core.fieldTerm = (Phantoms.unTTerm evaluationStyle)}, - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Phantoms.unTTerm input)}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Phantoms.unTTerm output)}]})) - -evaluationTestCaseEvaluationStyle :: Phantoms.TTerm Testing.EvaluationTestCase -> Phantoms.TTerm Testing.EvaluationStyle -evaluationTestCaseEvaluationStyle x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.EvaluationTestCase"), - Core.projectionField = (Core.Name "evaluationStyle")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -evaluationTestCaseInput :: Phantoms.TTerm Testing.EvaluationTestCase -> Phantoms.TTerm Core.Term -evaluationTestCaseInput x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.EvaluationTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -evaluationTestCaseOutput :: Phantoms.TTerm Testing.EvaluationTestCase -> Phantoms.TTerm Core.Term -evaluationTestCaseOutput x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.EvaluationTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -evaluationTestCaseWithEvaluationStyle :: Phantoms.TTerm Testing.EvaluationTestCase -> Phantoms.TTerm Testing.EvaluationStyle -> Phantoms.TTerm Testing.EvaluationTestCase -evaluationTestCaseWithEvaluationStyle original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.EvaluationTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "evaluationStyle"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.EvaluationTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.EvaluationTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -evaluationTestCaseWithInput :: Phantoms.TTerm Testing.EvaluationTestCase -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Testing.EvaluationTestCase -evaluationTestCaseWithInput original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.EvaluationTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "evaluationStyle"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.EvaluationTestCase"), - Core.projectionField = (Core.Name "evaluationStyle")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.EvaluationTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -evaluationTestCaseWithOutput :: Phantoms.TTerm Testing.EvaluationTestCase -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Testing.EvaluationTestCase -evaluationTestCaseWithOutput original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.EvaluationTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "evaluationStyle"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.EvaluationTestCase"), - Core.projectionField = (Core.Name "evaluationStyle")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.EvaluationTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -flattenLetTermsTestCase :: Phantoms.TTerm Core.Term -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Testing.FlattenLetTermsTestCase -flattenLetTermsTestCase input output = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.FlattenLetTermsTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Phantoms.unTTerm input)}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Phantoms.unTTerm output)}]})) - -flattenLetTermsTestCaseInput :: Phantoms.TTerm Testing.FlattenLetTermsTestCase -> Phantoms.TTerm Core.Term -flattenLetTermsTestCaseInput x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.FlattenLetTermsTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -flattenLetTermsTestCaseOutput :: Phantoms.TTerm Testing.FlattenLetTermsTestCase -> Phantoms.TTerm Core.Term -flattenLetTermsTestCaseOutput x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.FlattenLetTermsTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -flattenLetTermsTestCaseWithInput :: Phantoms.TTerm Testing.FlattenLetTermsTestCase -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Testing.FlattenLetTermsTestCase -flattenLetTermsTestCaseWithInput original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.FlattenLetTermsTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.FlattenLetTermsTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -flattenLetTermsTestCaseWithOutput :: Phantoms.TTerm Testing.FlattenLetTermsTestCase -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Testing.FlattenLetTermsTestCase -flattenLetTermsTestCaseWithOutput original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.FlattenLetTermsTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.FlattenLetTermsTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -foldOperationCollectLabels :: Phantoms.TTerm Testing.FoldOperation -foldOperationCollectLabels = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.FoldOperation"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "collectLabels"), - Core.fieldTerm = Core.TermUnit}})) - -foldOperationCollectListLengths :: Phantoms.TTerm Testing.FoldOperation -foldOperationCollectListLengths = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.FoldOperation"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "collectListLengths"), - Core.fieldTerm = Core.TermUnit}})) - -foldOperationSumInt32Literals :: Phantoms.TTerm Testing.FoldOperation -foldOperationSumInt32Literals = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.FoldOperation"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "sumInt32Literals"), - Core.fieldTerm = Core.TermUnit}})) - -foldOverTermTestCase :: Phantoms.TTerm Core.Term -> Phantoms.TTerm Coders.TraversalOrder -> Phantoms.TTerm Testing.FoldOperation -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Testing.FoldOverTermTestCase -foldOverTermTestCase input traversalOrder operation output = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.FoldOverTermTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Phantoms.unTTerm input)}, - Core.Field { - Core.fieldName = (Core.Name "traversalOrder"), - Core.fieldTerm = (Phantoms.unTTerm traversalOrder)}, - Core.Field { - Core.fieldName = (Core.Name "operation"), - Core.fieldTerm = (Phantoms.unTTerm operation)}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Phantoms.unTTerm output)}]})) - -foldOverTermTestCaseInput :: Phantoms.TTerm Testing.FoldOverTermTestCase -> Phantoms.TTerm Core.Term -foldOverTermTestCaseInput x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.FoldOverTermTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -foldOverTermTestCaseOperation :: Phantoms.TTerm Testing.FoldOverTermTestCase -> Phantoms.TTerm Testing.FoldOperation -foldOverTermTestCaseOperation x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.FoldOverTermTestCase"), - Core.projectionField = (Core.Name "operation")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -foldOverTermTestCaseOutput :: Phantoms.TTerm Testing.FoldOverTermTestCase -> Phantoms.TTerm Core.Term -foldOverTermTestCaseOutput x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.FoldOverTermTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -foldOverTermTestCaseTraversalOrder :: Phantoms.TTerm Testing.FoldOverTermTestCase -> Phantoms.TTerm Coders.TraversalOrder -foldOverTermTestCaseTraversalOrder x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.FoldOverTermTestCase"), - Core.projectionField = (Core.Name "traversalOrder")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -foldOverTermTestCaseWithInput :: Phantoms.TTerm Testing.FoldOverTermTestCase -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Testing.FoldOverTermTestCase -foldOverTermTestCaseWithInput original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.FoldOverTermTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "traversalOrder"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.FoldOverTermTestCase"), - Core.projectionField = (Core.Name "traversalOrder")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "operation"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.FoldOverTermTestCase"), - Core.projectionField = (Core.Name "operation")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.FoldOverTermTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -foldOverTermTestCaseWithOperation :: Phantoms.TTerm Testing.FoldOverTermTestCase -> Phantoms.TTerm Testing.FoldOperation -> Phantoms.TTerm Testing.FoldOverTermTestCase -foldOverTermTestCaseWithOperation original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.FoldOverTermTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.FoldOverTermTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "traversalOrder"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.FoldOverTermTestCase"), - Core.projectionField = (Core.Name "traversalOrder")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "operation"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.FoldOverTermTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -foldOverTermTestCaseWithOutput :: Phantoms.TTerm Testing.FoldOverTermTestCase -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Testing.FoldOverTermTestCase -foldOverTermTestCaseWithOutput original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.FoldOverTermTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.FoldOverTermTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "traversalOrder"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.FoldOverTermTestCase"), - Core.projectionField = (Core.Name "traversalOrder")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "operation"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.FoldOverTermTestCase"), - Core.projectionField = (Core.Name "operation")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -foldOverTermTestCaseWithTraversalOrder :: Phantoms.TTerm Testing.FoldOverTermTestCase -> Phantoms.TTerm Coders.TraversalOrder -> Phantoms.TTerm Testing.FoldOverTermTestCase -foldOverTermTestCaseWithTraversalOrder original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.FoldOverTermTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.FoldOverTermTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "traversalOrder"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "operation"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.FoldOverTermTestCase"), - Core.projectionField = (Core.Name "operation")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.FoldOverTermTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -freeVariablesTestCase :: Phantoms.TTerm Core.Term -> Phantoms.TTerm (S.Set Core.Name) -> Phantoms.TTerm Testing.FreeVariablesTestCase -freeVariablesTestCase input output = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.FreeVariablesTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Phantoms.unTTerm input)}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Phantoms.unTTerm output)}]})) - -freeVariablesTestCaseInput :: Phantoms.TTerm Testing.FreeVariablesTestCase -> Phantoms.TTerm Core.Term -freeVariablesTestCaseInput x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.FreeVariablesTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -freeVariablesTestCaseOutput :: Phantoms.TTerm Testing.FreeVariablesTestCase -> Phantoms.TTerm (S.Set Core.Name) -freeVariablesTestCaseOutput x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.FreeVariablesTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -freeVariablesTestCaseWithInput :: Phantoms.TTerm Testing.FreeVariablesTestCase -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Testing.FreeVariablesTestCase -freeVariablesTestCaseWithInput original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.FreeVariablesTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.FreeVariablesTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -freeVariablesTestCaseWithOutput :: Phantoms.TTerm Testing.FreeVariablesTestCase -> Phantoms.TTerm (S.Set Core.Name) -> Phantoms.TTerm Testing.FreeVariablesTestCase -freeVariablesTestCaseWithOutput original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.FreeVariablesTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.FreeVariablesTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -hoistCaseStatementsTestCase :: Phantoms.TTerm Core.Term -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Testing.HoistCaseStatementsTestCase -hoistCaseStatementsTestCase input output = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.HoistCaseStatementsTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Phantoms.unTTerm input)}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Phantoms.unTTerm output)}]})) - -hoistCaseStatementsTestCaseInput :: Phantoms.TTerm Testing.HoistCaseStatementsTestCase -> Phantoms.TTerm Core.Term -hoistCaseStatementsTestCaseInput x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.HoistCaseStatementsTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -hoistCaseStatementsTestCaseOutput :: Phantoms.TTerm Testing.HoistCaseStatementsTestCase -> Phantoms.TTerm Core.Term -hoistCaseStatementsTestCaseOutput x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.HoistCaseStatementsTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -hoistCaseStatementsTestCaseWithInput :: Phantoms.TTerm Testing.HoistCaseStatementsTestCase -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Testing.HoistCaseStatementsTestCase -hoistCaseStatementsTestCaseWithInput original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.HoistCaseStatementsTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.HoistCaseStatementsTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -hoistCaseStatementsTestCaseWithOutput :: Phantoms.TTerm Testing.HoistCaseStatementsTestCase -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Testing.HoistCaseStatementsTestCase -hoistCaseStatementsTestCaseWithOutput original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.HoistCaseStatementsTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.HoistCaseStatementsTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -hoistLetBindingsTestCase :: Phantoms.TTerm Core.Let -> Phantoms.TTerm Core.Let -> Phantoms.TTerm Testing.HoistLetBindingsTestCase -hoistLetBindingsTestCase input output = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.HoistLetBindingsTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Phantoms.unTTerm input)}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Phantoms.unTTerm output)}]})) - -hoistLetBindingsTestCaseInput :: Phantoms.TTerm Testing.HoistLetBindingsTestCase -> Phantoms.TTerm Core.Let -hoistLetBindingsTestCaseInput x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.HoistLetBindingsTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -hoistLetBindingsTestCaseOutput :: Phantoms.TTerm Testing.HoistLetBindingsTestCase -> Phantoms.TTerm Core.Let -hoistLetBindingsTestCaseOutput x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.HoistLetBindingsTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -hoistLetBindingsTestCaseWithInput :: Phantoms.TTerm Testing.HoistLetBindingsTestCase -> Phantoms.TTerm Core.Let -> Phantoms.TTerm Testing.HoistLetBindingsTestCase -hoistLetBindingsTestCaseWithInput original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.HoistLetBindingsTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.HoistLetBindingsTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -hoistLetBindingsTestCaseWithOutput :: Phantoms.TTerm Testing.HoistLetBindingsTestCase -> Phantoms.TTerm Core.Let -> Phantoms.TTerm Testing.HoistLetBindingsTestCase -hoistLetBindingsTestCaseWithOutput original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.HoistLetBindingsTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.HoistLetBindingsTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -hoistPolymorphicLetBindingsTestCase :: Phantoms.TTerm Core.Let -> Phantoms.TTerm Core.Let -> Phantoms.TTerm Testing.HoistPolymorphicLetBindingsTestCase -hoistPolymorphicLetBindingsTestCase input output = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.HoistPolymorphicLetBindingsTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Phantoms.unTTerm input)}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Phantoms.unTTerm output)}]})) - -hoistPolymorphicLetBindingsTestCaseInput :: Phantoms.TTerm Testing.HoistPolymorphicLetBindingsTestCase -> Phantoms.TTerm Core.Let -hoistPolymorphicLetBindingsTestCaseInput x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.HoistPolymorphicLetBindingsTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -hoistPolymorphicLetBindingsTestCaseOutput :: Phantoms.TTerm Testing.HoistPolymorphicLetBindingsTestCase -> Phantoms.TTerm Core.Let -hoistPolymorphicLetBindingsTestCaseOutput x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.HoistPolymorphicLetBindingsTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -hoistPolymorphicLetBindingsTestCaseWithInput :: Phantoms.TTerm Testing.HoistPolymorphicLetBindingsTestCase -> Phantoms.TTerm Core.Let -> Phantoms.TTerm Testing.HoistPolymorphicLetBindingsTestCase -hoistPolymorphicLetBindingsTestCaseWithInput original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.HoistPolymorphicLetBindingsTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.HoistPolymorphicLetBindingsTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -hoistPolymorphicLetBindingsTestCaseWithOutput :: Phantoms.TTerm Testing.HoistPolymorphicLetBindingsTestCase -> Phantoms.TTerm Core.Let -> Phantoms.TTerm Testing.HoistPolymorphicLetBindingsTestCase -hoistPolymorphicLetBindingsTestCaseWithOutput original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.HoistPolymorphicLetBindingsTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.HoistPolymorphicLetBindingsTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -hoistPredicateApplications :: Phantoms.TTerm Testing.HoistPredicate -hoistPredicateApplications = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.HoistPredicate"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "applications"), - Core.fieldTerm = Core.TermUnit}})) - -hoistPredicateCaseStatements :: Phantoms.TTerm Testing.HoistPredicate -hoistPredicateCaseStatements = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.HoistPredicate"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "caseStatements"), - Core.fieldTerm = Core.TermUnit}})) - -hoistPredicateLists :: Phantoms.TTerm Testing.HoistPredicate -hoistPredicateLists = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.HoistPredicate"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "lists"), - Core.fieldTerm = Core.TermUnit}})) - -hoistPredicateNothing :: Phantoms.TTerm Testing.HoistPredicate -hoistPredicateNothing = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.HoistPredicate"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "nothing"), - Core.fieldTerm = Core.TermUnit}})) - -hoistSubtermsTestCase :: Phantoms.TTerm Testing.HoistPredicate -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Testing.HoistSubtermsTestCase -hoistSubtermsTestCase predicate input output = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.HoistSubtermsTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "predicate"), - Core.fieldTerm = (Phantoms.unTTerm predicate)}, - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Phantoms.unTTerm input)}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Phantoms.unTTerm output)}]})) - -hoistSubtermsTestCaseInput :: Phantoms.TTerm Testing.HoistSubtermsTestCase -> Phantoms.TTerm Core.Term -hoistSubtermsTestCaseInput x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.HoistSubtermsTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -hoistSubtermsTestCaseOutput :: Phantoms.TTerm Testing.HoistSubtermsTestCase -> Phantoms.TTerm Core.Term -hoistSubtermsTestCaseOutput x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.HoistSubtermsTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -hoistSubtermsTestCasePredicate :: Phantoms.TTerm Testing.HoistSubtermsTestCase -> Phantoms.TTerm Testing.HoistPredicate -hoistSubtermsTestCasePredicate x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.HoistSubtermsTestCase"), - Core.projectionField = (Core.Name "predicate")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -hoistSubtermsTestCaseWithInput :: Phantoms.TTerm Testing.HoistSubtermsTestCase -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Testing.HoistSubtermsTestCase -hoistSubtermsTestCaseWithInput original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.HoistSubtermsTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "predicate"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.HoistSubtermsTestCase"), - Core.projectionField = (Core.Name "predicate")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.HoistSubtermsTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -hoistSubtermsTestCaseWithOutput :: Phantoms.TTerm Testing.HoistSubtermsTestCase -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Testing.HoistSubtermsTestCase -hoistSubtermsTestCaseWithOutput original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.HoistSubtermsTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "predicate"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.HoistSubtermsTestCase"), - Core.projectionField = (Core.Name "predicate")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.HoistSubtermsTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -hoistSubtermsTestCaseWithPredicate :: Phantoms.TTerm Testing.HoistSubtermsTestCase -> Phantoms.TTerm Testing.HoistPredicate -> Phantoms.TTerm Testing.HoistSubtermsTestCase -hoistSubtermsTestCaseWithPredicate original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.HoistSubtermsTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "predicate"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.HoistSubtermsTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.HoistSubtermsTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -inferenceFailureTestCase :: Phantoms.TTerm Core.Term -> Phantoms.TTerm Testing.InferenceFailureTestCase -inferenceFailureTestCase input = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.InferenceFailureTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Phantoms.unTTerm input)}]})) - -inferenceFailureTestCaseInput :: Phantoms.TTerm Testing.InferenceFailureTestCase -> Phantoms.TTerm Core.Term -inferenceFailureTestCaseInput x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.InferenceFailureTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -inferenceFailureTestCaseWithInput :: Phantoms.TTerm Testing.InferenceFailureTestCase -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Testing.InferenceFailureTestCase -inferenceFailureTestCaseWithInput original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.InferenceFailureTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -inferenceTestCase :: Phantoms.TTerm Core.Term -> Phantoms.TTerm Core.TypeScheme -> Phantoms.TTerm Testing.InferenceTestCase -inferenceTestCase input output = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.InferenceTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Phantoms.unTTerm input)}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Phantoms.unTTerm output)}]})) - -inferenceTestCaseInput :: Phantoms.TTerm Testing.InferenceTestCase -> Phantoms.TTerm Core.Term -inferenceTestCaseInput x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.InferenceTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -inferenceTestCaseOutput :: Phantoms.TTerm Testing.InferenceTestCase -> Phantoms.TTerm Core.TypeScheme -inferenceTestCaseOutput x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.InferenceTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -inferenceTestCaseWithInput :: Phantoms.TTerm Testing.InferenceTestCase -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Testing.InferenceTestCase -inferenceTestCaseWithInput original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.InferenceTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.InferenceTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -inferenceTestCaseWithOutput :: Phantoms.TTerm Testing.InferenceTestCase -> Phantoms.TTerm Core.TypeScheme -> Phantoms.TTerm Testing.InferenceTestCase -inferenceTestCaseWithOutput original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.InferenceTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.InferenceTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -joinTypesTestCase :: Phantoms.TTerm Core.Type -> Phantoms.TTerm Core.Type -> Phantoms.TTerm (Either () [Typing.TypeConstraint]) -> Phantoms.TTerm Testing.JoinTypesTestCase -joinTypesTestCase left right expected = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.JoinTypesTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "left"), - Core.fieldTerm = (Phantoms.unTTerm left)}, - Core.Field { - Core.fieldName = (Core.Name "right"), - Core.fieldTerm = (Phantoms.unTTerm right)}, - Core.Field { - Core.fieldName = (Core.Name "expected"), - Core.fieldTerm = (Phantoms.unTTerm expected)}]})) - -joinTypesTestCaseExpected :: Phantoms.TTerm Testing.JoinTypesTestCase -> Phantoms.TTerm (Either () [Typing.TypeConstraint]) -joinTypesTestCaseExpected x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.JoinTypesTestCase"), - Core.projectionField = (Core.Name "expected")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -joinTypesTestCaseLeft :: Phantoms.TTerm Testing.JoinTypesTestCase -> Phantoms.TTerm Core.Type -joinTypesTestCaseLeft x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.JoinTypesTestCase"), - Core.projectionField = (Core.Name "left")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -joinTypesTestCaseRight :: Phantoms.TTerm Testing.JoinTypesTestCase -> Phantoms.TTerm Core.Type -joinTypesTestCaseRight x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.JoinTypesTestCase"), - Core.projectionField = (Core.Name "right")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -joinTypesTestCaseWithExpected :: Phantoms.TTerm Testing.JoinTypesTestCase -> Phantoms.TTerm (Either () [Typing.TypeConstraint]) -> Phantoms.TTerm Testing.JoinTypesTestCase -joinTypesTestCaseWithExpected original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.JoinTypesTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "left"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.JoinTypesTestCase"), - Core.projectionField = (Core.Name "left")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "right"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.JoinTypesTestCase"), - Core.projectionField = (Core.Name "right")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "expected"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -joinTypesTestCaseWithLeft :: Phantoms.TTerm Testing.JoinTypesTestCase -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Testing.JoinTypesTestCase -joinTypesTestCaseWithLeft original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.JoinTypesTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "left"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "right"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.JoinTypesTestCase"), - Core.projectionField = (Core.Name "right")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "expected"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.JoinTypesTestCase"), - Core.projectionField = (Core.Name "expected")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -joinTypesTestCaseWithRight :: Phantoms.TTerm Testing.JoinTypesTestCase -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Testing.JoinTypesTestCase -joinTypesTestCaseWithRight original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.JoinTypesTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "left"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.JoinTypesTestCase"), - Core.projectionField = (Core.Name "left")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "right"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "expected"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.JoinTypesTestCase"), - Core.projectionField = (Core.Name "expected")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -jsonDecodeTestCase :: Phantoms.TTerm Core.Type -> Phantoms.TTerm Model.Value -> Phantoms.TTerm (Either String Core.Term) -> Phantoms.TTerm Testing.JsonDecodeTestCase -jsonDecodeTestCase type_ json expected = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.JsonDecodeTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Phantoms.unTTerm type_)}, - Core.Field { - Core.fieldName = (Core.Name "json"), - Core.fieldTerm = (Phantoms.unTTerm json)}, - Core.Field { - Core.fieldName = (Core.Name "expected"), - Core.fieldTerm = (Phantoms.unTTerm expected)}]})) - -jsonDecodeTestCaseExpected :: Phantoms.TTerm Testing.JsonDecodeTestCase -> Phantoms.TTerm (Either String Core.Term) -jsonDecodeTestCaseExpected x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.JsonDecodeTestCase"), - Core.projectionField = (Core.Name "expected")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -jsonDecodeTestCaseJson :: Phantoms.TTerm Testing.JsonDecodeTestCase -> Phantoms.TTerm Model.Value -jsonDecodeTestCaseJson x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.JsonDecodeTestCase"), - Core.projectionField = (Core.Name "json")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -jsonDecodeTestCaseType :: Phantoms.TTerm Testing.JsonDecodeTestCase -> Phantoms.TTerm Core.Type -jsonDecodeTestCaseType x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.JsonDecodeTestCase"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -jsonDecodeTestCaseWithExpected :: Phantoms.TTerm Testing.JsonDecodeTestCase -> Phantoms.TTerm (Either String Core.Term) -> Phantoms.TTerm Testing.JsonDecodeTestCase -jsonDecodeTestCaseWithExpected original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.JsonDecodeTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.JsonDecodeTestCase"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "json"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.JsonDecodeTestCase"), - Core.projectionField = (Core.Name "json")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "expected"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -jsonDecodeTestCaseWithJson :: Phantoms.TTerm Testing.JsonDecodeTestCase -> Phantoms.TTerm Model.Value -> Phantoms.TTerm Testing.JsonDecodeTestCase -jsonDecodeTestCaseWithJson original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.JsonDecodeTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.JsonDecodeTestCase"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "json"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "expected"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.JsonDecodeTestCase"), - Core.projectionField = (Core.Name "expected")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -jsonDecodeTestCaseWithType :: Phantoms.TTerm Testing.JsonDecodeTestCase -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Testing.JsonDecodeTestCase -jsonDecodeTestCaseWithType original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.JsonDecodeTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "json"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.JsonDecodeTestCase"), - Core.projectionField = (Core.Name "json")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "expected"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.JsonDecodeTestCase"), - Core.projectionField = (Core.Name "expected")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -jsonEncodeTestCase :: Phantoms.TTerm Core.Term -> Phantoms.TTerm (Either String Model.Value) -> Phantoms.TTerm Testing.JsonEncodeTestCase -jsonEncodeTestCase term expected = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.JsonEncodeTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Phantoms.unTTerm term)}, - Core.Field { - Core.fieldName = (Core.Name "expected"), - Core.fieldTerm = (Phantoms.unTTerm expected)}]})) - -jsonEncodeTestCaseExpected :: Phantoms.TTerm Testing.JsonEncodeTestCase -> Phantoms.TTerm (Either String Model.Value) -jsonEncodeTestCaseExpected x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.JsonEncodeTestCase"), - Core.projectionField = (Core.Name "expected")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -jsonEncodeTestCaseTerm :: Phantoms.TTerm Testing.JsonEncodeTestCase -> Phantoms.TTerm Core.Term -jsonEncodeTestCaseTerm x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.JsonEncodeTestCase"), - Core.projectionField = (Core.Name "term")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -jsonEncodeTestCaseWithExpected :: Phantoms.TTerm Testing.JsonEncodeTestCase -> Phantoms.TTerm (Either String Model.Value) -> Phantoms.TTerm Testing.JsonEncodeTestCase -jsonEncodeTestCaseWithExpected original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.JsonEncodeTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.JsonEncodeTestCase"), - Core.projectionField = (Core.Name "term")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "expected"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -jsonEncodeTestCaseWithTerm :: Phantoms.TTerm Testing.JsonEncodeTestCase -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Testing.JsonEncodeTestCase -jsonEncodeTestCaseWithTerm original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.JsonEncodeTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "expected"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.JsonEncodeTestCase"), - Core.projectionField = (Core.Name "expected")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -jsonRoundtripTestCase :: Phantoms.TTerm Core.Type -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Testing.JsonRoundtripTestCase -jsonRoundtripTestCase type_ term = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.JsonRoundtripTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Phantoms.unTTerm type_)}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Phantoms.unTTerm term)}]})) - -jsonRoundtripTestCaseTerm :: Phantoms.TTerm Testing.JsonRoundtripTestCase -> Phantoms.TTerm Core.Term -jsonRoundtripTestCaseTerm x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.JsonRoundtripTestCase"), - Core.projectionField = (Core.Name "term")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -jsonRoundtripTestCaseType :: Phantoms.TTerm Testing.JsonRoundtripTestCase -> Phantoms.TTerm Core.Type -jsonRoundtripTestCaseType x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.JsonRoundtripTestCase"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -jsonRoundtripTestCaseWithTerm :: Phantoms.TTerm Testing.JsonRoundtripTestCase -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Testing.JsonRoundtripTestCase -jsonRoundtripTestCaseWithTerm original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.JsonRoundtripTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.JsonRoundtripTestCase"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -jsonRoundtripTestCaseWithType :: Phantoms.TTerm Testing.JsonRoundtripTestCase -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Testing.JsonRoundtripTestCase -jsonRoundtripTestCaseWithType original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.JsonRoundtripTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.JsonRoundtripTestCase"), - Core.projectionField = (Core.Name "term")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -liftLambdaAboveLetTestCase :: Phantoms.TTerm Core.Term -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Testing.LiftLambdaAboveLetTestCase -liftLambdaAboveLetTestCase input output = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.LiftLambdaAboveLetTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Phantoms.unTTerm input)}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Phantoms.unTTerm output)}]})) - -liftLambdaAboveLetTestCaseInput :: Phantoms.TTerm Testing.LiftLambdaAboveLetTestCase -> Phantoms.TTerm Core.Term -liftLambdaAboveLetTestCaseInput x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.LiftLambdaAboveLetTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -liftLambdaAboveLetTestCaseOutput :: Phantoms.TTerm Testing.LiftLambdaAboveLetTestCase -> Phantoms.TTerm Core.Term -liftLambdaAboveLetTestCaseOutput x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.LiftLambdaAboveLetTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -liftLambdaAboveLetTestCaseWithInput :: Phantoms.TTerm Testing.LiftLambdaAboveLetTestCase -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Testing.LiftLambdaAboveLetTestCase -liftLambdaAboveLetTestCaseWithInput original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.LiftLambdaAboveLetTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.LiftLambdaAboveLetTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -liftLambdaAboveLetTestCaseWithOutput :: Phantoms.TTerm Testing.LiftLambdaAboveLetTestCase -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Testing.LiftLambdaAboveLetTestCase -liftLambdaAboveLetTestCaseWithOutput original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.LiftLambdaAboveLetTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.LiftLambdaAboveLetTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -normalizeTypeVariablesTestCase :: Phantoms.TTerm Core.Term -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Testing.NormalizeTypeVariablesTestCase -normalizeTypeVariablesTestCase input output = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.NormalizeTypeVariablesTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Phantoms.unTTerm input)}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Phantoms.unTTerm output)}]})) - -normalizeTypeVariablesTestCaseInput :: Phantoms.TTerm Testing.NormalizeTypeVariablesTestCase -> Phantoms.TTerm Core.Term -normalizeTypeVariablesTestCaseInput x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.NormalizeTypeVariablesTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -normalizeTypeVariablesTestCaseOutput :: Phantoms.TTerm Testing.NormalizeTypeVariablesTestCase -> Phantoms.TTerm Core.Term -normalizeTypeVariablesTestCaseOutput x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.NormalizeTypeVariablesTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -normalizeTypeVariablesTestCaseWithInput :: Phantoms.TTerm Testing.NormalizeTypeVariablesTestCase -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Testing.NormalizeTypeVariablesTestCase -normalizeTypeVariablesTestCaseWithInput original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.NormalizeTypeVariablesTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.NormalizeTypeVariablesTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -normalizeTypeVariablesTestCaseWithOutput :: Phantoms.TTerm Testing.NormalizeTypeVariablesTestCase -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Testing.NormalizeTypeVariablesTestCase -normalizeTypeVariablesTestCaseWithOutput original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.NormalizeTypeVariablesTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.NormalizeTypeVariablesTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -parserTestCase :: Phantoms.TTerm String -> Phantoms.TTerm (Parsing.ParseResult a) -> Phantoms.TTerm (Testing.ParserTestCase a) -parserTestCase input output = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.ParserTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Phantoms.unTTerm input)}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Phantoms.unTTerm output)}]})) - -parserTestCaseInput :: Phantoms.TTerm (Testing.ParserTestCase a) -> Phantoms.TTerm String -parserTestCaseInput x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.ParserTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -parserTestCaseOutput :: Phantoms.TTerm (Testing.ParserTestCase a) -> Phantoms.TTerm (Parsing.ParseResult a) -parserTestCaseOutput x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.ParserTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -parserTestCaseWithInput :: Phantoms.TTerm (Testing.ParserTestCase a) -> Phantoms.TTerm String -> Phantoms.TTerm (Testing.ParserTestCase a) -parserTestCaseWithInput original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.ParserTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.ParserTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -parserTestCaseWithOutput :: Phantoms.TTerm (Testing.ParserTestCase a) -> Phantoms.TTerm (Parsing.ParseResult a) -> Phantoms.TTerm (Testing.ParserTestCase a) -parserTestCaseWithOutput original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.ParserTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.ParserTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -rewriteTermTestCase :: Phantoms.TTerm Core.Term -> Phantoms.TTerm Testing.TermRewriter -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Testing.RewriteTermTestCase -rewriteTermTestCase input rewriter output = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.RewriteTermTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Phantoms.unTTerm input)}, - Core.Field { - Core.fieldName = (Core.Name "rewriter"), - Core.fieldTerm = (Phantoms.unTTerm rewriter)}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Phantoms.unTTerm output)}]})) - -rewriteTermTestCaseInput :: Phantoms.TTerm Testing.RewriteTermTestCase -> Phantoms.TTerm Core.Term -rewriteTermTestCaseInput x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.RewriteTermTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -rewriteTermTestCaseOutput :: Phantoms.TTerm Testing.RewriteTermTestCase -> Phantoms.TTerm Core.Term -rewriteTermTestCaseOutput x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.RewriteTermTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -rewriteTermTestCaseRewriter :: Phantoms.TTerm Testing.RewriteTermTestCase -> Phantoms.TTerm Testing.TermRewriter -rewriteTermTestCaseRewriter x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.RewriteTermTestCase"), - Core.projectionField = (Core.Name "rewriter")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -rewriteTermTestCaseWithInput :: Phantoms.TTerm Testing.RewriteTermTestCase -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Testing.RewriteTermTestCase -rewriteTermTestCaseWithInput original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.RewriteTermTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "rewriter"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.RewriteTermTestCase"), - Core.projectionField = (Core.Name "rewriter")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.RewriteTermTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -rewriteTermTestCaseWithOutput :: Phantoms.TTerm Testing.RewriteTermTestCase -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Testing.RewriteTermTestCase -rewriteTermTestCaseWithOutput original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.RewriteTermTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.RewriteTermTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "rewriter"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.RewriteTermTestCase"), - Core.projectionField = (Core.Name "rewriter")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -rewriteTermTestCaseWithRewriter :: Phantoms.TTerm Testing.RewriteTermTestCase -> Phantoms.TTerm Testing.TermRewriter -> Phantoms.TTerm Testing.RewriteTermTestCase -rewriteTermTestCaseWithRewriter original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.RewriteTermTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.RewriteTermTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "rewriter"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.RewriteTermTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -rewriteTypeTestCase :: Phantoms.TTerm Core.Type -> Phantoms.TTerm Testing.TypeRewriter -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Testing.RewriteTypeTestCase -rewriteTypeTestCase input rewriter output = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.RewriteTypeTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Phantoms.unTTerm input)}, - Core.Field { - Core.fieldName = (Core.Name "rewriter"), - Core.fieldTerm = (Phantoms.unTTerm rewriter)}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Phantoms.unTTerm output)}]})) - -rewriteTypeTestCaseInput :: Phantoms.TTerm Testing.RewriteTypeTestCase -> Phantoms.TTerm Core.Type -rewriteTypeTestCaseInput x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.RewriteTypeTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -rewriteTypeTestCaseOutput :: Phantoms.TTerm Testing.RewriteTypeTestCase -> Phantoms.TTerm Core.Type -rewriteTypeTestCaseOutput x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.RewriteTypeTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -rewriteTypeTestCaseRewriter :: Phantoms.TTerm Testing.RewriteTypeTestCase -> Phantoms.TTerm Testing.TypeRewriter -rewriteTypeTestCaseRewriter x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.RewriteTypeTestCase"), - Core.projectionField = (Core.Name "rewriter")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -rewriteTypeTestCaseWithInput :: Phantoms.TTerm Testing.RewriteTypeTestCase -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Testing.RewriteTypeTestCase -rewriteTypeTestCaseWithInput original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.RewriteTypeTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "rewriter"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.RewriteTypeTestCase"), - Core.projectionField = (Core.Name "rewriter")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.RewriteTypeTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -rewriteTypeTestCaseWithOutput :: Phantoms.TTerm Testing.RewriteTypeTestCase -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Testing.RewriteTypeTestCase -rewriteTypeTestCaseWithOutput original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.RewriteTypeTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.RewriteTypeTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "rewriter"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.RewriteTypeTestCase"), - Core.projectionField = (Core.Name "rewriter")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -rewriteTypeTestCaseWithRewriter :: Phantoms.TTerm Testing.RewriteTypeTestCase -> Phantoms.TTerm Testing.TypeRewriter -> Phantoms.TTerm Testing.RewriteTypeTestCase -rewriteTypeTestCaseWithRewriter original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.RewriteTypeTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.RewriteTypeTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "rewriter"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.RewriteTypeTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -serializationTestCase :: Phantoms.TTerm Ast.Expr -> Phantoms.TTerm String -> Phantoms.TTerm Testing.SerializationTestCase -serializationTestCase input output = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.SerializationTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Phantoms.unTTerm input)}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Phantoms.unTTerm output)}]})) - -serializationTestCaseInput :: Phantoms.TTerm Testing.SerializationTestCase -> Phantoms.TTerm Ast.Expr -serializationTestCaseInput x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.SerializationTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -serializationTestCaseOutput :: Phantoms.TTerm Testing.SerializationTestCase -> Phantoms.TTerm String -serializationTestCaseOutput x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.SerializationTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -serializationTestCaseWithInput :: Phantoms.TTerm Testing.SerializationTestCase -> Phantoms.TTerm Ast.Expr -> Phantoms.TTerm Testing.SerializationTestCase -serializationTestCaseWithInput original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.SerializationTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.SerializationTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -serializationTestCaseWithOutput :: Phantoms.TTerm Testing.SerializationTestCase -> Phantoms.TTerm String -> Phantoms.TTerm Testing.SerializationTestCase -serializationTestCaseWithOutput original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.SerializationTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.SerializationTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -simplifyTermTestCase :: Phantoms.TTerm Core.Term -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Testing.SimplifyTermTestCase -simplifyTermTestCase input output = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.SimplifyTermTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Phantoms.unTTerm input)}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Phantoms.unTTerm output)}]})) - -simplifyTermTestCaseInput :: Phantoms.TTerm Testing.SimplifyTermTestCase -> Phantoms.TTerm Core.Term -simplifyTermTestCaseInput x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.SimplifyTermTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -simplifyTermTestCaseOutput :: Phantoms.TTerm Testing.SimplifyTermTestCase -> Phantoms.TTerm Core.Term -simplifyTermTestCaseOutput x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.SimplifyTermTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -simplifyTermTestCaseWithInput :: Phantoms.TTerm Testing.SimplifyTermTestCase -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Testing.SimplifyTermTestCase -simplifyTermTestCaseWithInput original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.SimplifyTermTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.SimplifyTermTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -simplifyTermTestCaseWithOutput :: Phantoms.TTerm Testing.SimplifyTermTestCase -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Testing.SimplifyTermTestCase -simplifyTermTestCaseWithOutput original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.SimplifyTermTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.SimplifyTermTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -substInTypeTestCase :: Phantoms.TTerm [(Core.Name, Core.Type)] -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Testing.SubstInTypeTestCase -substInTypeTestCase substitution input output = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.SubstInTypeTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "substitution"), - Core.fieldTerm = (Phantoms.unTTerm substitution)}, - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Phantoms.unTTerm input)}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Phantoms.unTTerm output)}]})) - -substInTypeTestCaseInput :: Phantoms.TTerm Testing.SubstInTypeTestCase -> Phantoms.TTerm Core.Type -substInTypeTestCaseInput x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.SubstInTypeTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -substInTypeTestCaseOutput :: Phantoms.TTerm Testing.SubstInTypeTestCase -> Phantoms.TTerm Core.Type -substInTypeTestCaseOutput x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.SubstInTypeTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -substInTypeTestCaseSubstitution :: Phantoms.TTerm Testing.SubstInTypeTestCase -> Phantoms.TTerm [(Core.Name, Core.Type)] -substInTypeTestCaseSubstitution x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.SubstInTypeTestCase"), - Core.projectionField = (Core.Name "substitution")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -substInTypeTestCaseWithInput :: Phantoms.TTerm Testing.SubstInTypeTestCase -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Testing.SubstInTypeTestCase -substInTypeTestCaseWithInput original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.SubstInTypeTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "substitution"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.SubstInTypeTestCase"), - Core.projectionField = (Core.Name "substitution")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.SubstInTypeTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -substInTypeTestCaseWithOutput :: Phantoms.TTerm Testing.SubstInTypeTestCase -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Testing.SubstInTypeTestCase -substInTypeTestCaseWithOutput original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.SubstInTypeTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "substitution"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.SubstInTypeTestCase"), - Core.projectionField = (Core.Name "substitution")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.SubstInTypeTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -substInTypeTestCaseWithSubstitution :: Phantoms.TTerm Testing.SubstInTypeTestCase -> Phantoms.TTerm [(Core.Name, Core.Type)] -> Phantoms.TTerm Testing.SubstInTypeTestCase -substInTypeTestCaseWithSubstitution original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.SubstInTypeTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "substitution"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.SubstInTypeTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.SubstInTypeTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -tag :: Phantoms.TTerm String -> Phantoms.TTerm Testing.Tag -tag x = - Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.testing.Tag"), - Core.wrappedTermBody = (Phantoms.unTTerm x)})) - -termRewriterReplaceFooWithBar :: Phantoms.TTerm Testing.TermRewriter -termRewriterReplaceFooWithBar = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TermRewriter"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "replaceFooWithBar"), - Core.fieldTerm = Core.TermUnit}})) - -termRewriterReplaceInt32WithInt64 :: Phantoms.TTerm Testing.TermRewriter -termRewriterReplaceInt32WithInt64 = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TermRewriter"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "replaceInt32WithInt64"), - Core.fieldTerm = Core.TermUnit}})) - -testCaseAlphaConversion :: Phantoms.TTerm Testing.AlphaConversionTestCase -> Phantoms.TTerm Testing.TestCase -testCaseAlphaConversion x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "alphaConversion"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -testCaseCaseConversion :: Phantoms.TTerm Testing.CaseConversionTestCase -> Phantoms.TTerm Testing.TestCase -testCaseCaseConversion x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "caseConversion"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -testCaseDeannotateTerm :: Phantoms.TTerm Testing.DeannotateTermTestCase -> Phantoms.TTerm Testing.TestCase -testCaseDeannotateTerm x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "deannotateTerm"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -testCaseDeannotateType :: Phantoms.TTerm Testing.DeannotateTypeTestCase -> Phantoms.TTerm Testing.TestCase -testCaseDeannotateType x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "deannotateType"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -testCaseDelegatedEvaluation :: Phantoms.TTerm Testing.DelegatedEvaluationTestCase -> Phantoms.TTerm Testing.TestCase -testCaseDelegatedEvaluation x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "delegatedEvaluation"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -testCaseEtaExpansion :: Phantoms.TTerm Testing.EtaExpansionTestCase -> Phantoms.TTerm Testing.TestCase -testCaseEtaExpansion x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "etaExpansion"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -testCaseEvaluation :: Phantoms.TTerm Testing.EvaluationTestCase -> Phantoms.TTerm Testing.TestCase -testCaseEvaluation x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "evaluation"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -testCaseFlattenLetTerms :: Phantoms.TTerm Testing.FlattenLetTermsTestCase -> Phantoms.TTerm Testing.TestCase -testCaseFlattenLetTerms x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "flattenLetTerms"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -testCaseFoldOverTerm :: Phantoms.TTerm Testing.FoldOverTermTestCase -> Phantoms.TTerm Testing.TestCase -testCaseFoldOverTerm x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "foldOverTerm"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -testCaseFreeVariables :: Phantoms.TTerm Testing.FreeVariablesTestCase -> Phantoms.TTerm Testing.TestCase -testCaseFreeVariables x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "freeVariables"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -testCaseHoistCaseStatements :: Phantoms.TTerm Testing.HoistCaseStatementsTestCase -> Phantoms.TTerm Testing.TestCase -testCaseHoistCaseStatements x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "hoistCaseStatements"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -testCaseHoistLetBindings :: Phantoms.TTerm Testing.HoistLetBindingsTestCase -> Phantoms.TTerm Testing.TestCase -testCaseHoistLetBindings x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "hoistLetBindings"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -testCaseHoistPolymorphicLetBindings :: Phantoms.TTerm Testing.HoistPolymorphicLetBindingsTestCase -> Phantoms.TTerm Testing.TestCase -testCaseHoistPolymorphicLetBindings x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "hoistPolymorphicLetBindings"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -testCaseHoistSubterms :: Phantoms.TTerm Testing.HoistSubtermsTestCase -> Phantoms.TTerm Testing.TestCase -testCaseHoistSubterms x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "hoistSubterms"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -testCaseInference :: Phantoms.TTerm Testing.InferenceTestCase -> Phantoms.TTerm Testing.TestCase -testCaseInference x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inference"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -testCaseInferenceFailure :: Phantoms.TTerm Testing.InferenceFailureTestCase -> Phantoms.TTerm Testing.TestCase -testCaseInferenceFailure x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inferenceFailure"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -testCaseJoinTypes :: Phantoms.TTerm Testing.JoinTypesTestCase -> Phantoms.TTerm Testing.TestCase -testCaseJoinTypes x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "joinTypes"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -testCaseJsonDecode :: Phantoms.TTerm Testing.JsonDecodeTestCase -> Phantoms.TTerm Testing.TestCase -testCaseJsonDecode x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "jsonDecode"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -testCaseJsonEncode :: Phantoms.TTerm Testing.JsonEncodeTestCase -> Phantoms.TTerm Testing.TestCase -testCaseJsonEncode x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "jsonEncode"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -testCaseJsonParser :: Phantoms.TTerm Testing.JsonParserTestCase -> Phantoms.TTerm Testing.TestCase -testCaseJsonParser x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "jsonParser"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -testCaseJsonRoundtrip :: Phantoms.TTerm Testing.JsonRoundtripTestCase -> Phantoms.TTerm Testing.TestCase -testCaseJsonRoundtrip x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "jsonRoundtrip"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -testCaseJsonWriter :: Phantoms.TTerm Testing.JsonWriterTestCase -> Phantoms.TTerm Testing.TestCase -testCaseJsonWriter x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "jsonWriter"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -testCaseLiftLambdaAboveLet :: Phantoms.TTerm Testing.LiftLambdaAboveLetTestCase -> Phantoms.TTerm Testing.TestCase -testCaseLiftLambdaAboveLet x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "liftLambdaAboveLet"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -testCaseNormalizeTypeVariables :: Phantoms.TTerm Testing.NormalizeTypeVariablesTestCase -> Phantoms.TTerm Testing.TestCase -testCaseNormalizeTypeVariables x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "normalizeTypeVariables"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -testCaseRewriteTerm :: Phantoms.TTerm Testing.RewriteTermTestCase -> Phantoms.TTerm Testing.TestCase -testCaseRewriteTerm x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "rewriteTerm"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -testCaseRewriteType :: Phantoms.TTerm Testing.RewriteTypeTestCase -> Phantoms.TTerm Testing.TestCase -testCaseRewriteType x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "rewriteType"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -testCaseSerialization :: Phantoms.TTerm Testing.SerializationTestCase -> Phantoms.TTerm Testing.TestCase -testCaseSerialization x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "serialization"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -testCaseSimplifyTerm :: Phantoms.TTerm Testing.SimplifyTermTestCase -> Phantoms.TTerm Testing.TestCase -testCaseSimplifyTerm x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "simplifyTerm"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -testCaseSubstInType :: Phantoms.TTerm Testing.SubstInTypeTestCase -> Phantoms.TTerm Testing.TestCase -testCaseSubstInType x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "substInType"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -testCaseTopologicalSort :: Phantoms.TTerm Testing.TopologicalSortTestCase -> Phantoms.TTerm Testing.TestCase -testCaseTopologicalSort x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "topologicalSort"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -testCaseTopologicalSortBindings :: Phantoms.TTerm Testing.TopologicalSortBindingsTestCase -> Phantoms.TTerm Testing.TestCase -testCaseTopologicalSortBindings x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "topologicalSortBindings"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -testCaseTopologicalSortSCC :: Phantoms.TTerm Testing.TopologicalSortSCCTestCase -> Phantoms.TTerm Testing.TestCase -testCaseTopologicalSortSCC x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "topologicalSortSCC"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -testCaseTypeChecking :: Phantoms.TTerm Testing.TypeCheckingTestCase -> Phantoms.TTerm Testing.TestCase -testCaseTypeChecking x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "typeChecking"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -testCaseTypeCheckingFailure :: Phantoms.TTerm Testing.TypeCheckingFailureTestCase -> Phantoms.TTerm Testing.TestCase -testCaseTypeCheckingFailure x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "typeCheckingFailure"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -testCaseTypeReduction :: Phantoms.TTerm Testing.TypeReductionTestCase -> Phantoms.TTerm Testing.TestCase -testCaseTypeReduction x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "typeReduction"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -testCaseUnifyTypes :: Phantoms.TTerm Testing.UnifyTypesTestCase -> Phantoms.TTerm Testing.TestCase -testCaseUnifyTypes x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unifyTypes"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -testCaseUnshadowVariables :: Phantoms.TTerm Testing.UnshadowVariablesTestCase -> Phantoms.TTerm Testing.TestCase -testCaseUnshadowVariables x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unshadowVariables"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -testCaseValidateCoreTerm :: Phantoms.TTerm Testing.ValidateCoreTermTestCase -> Phantoms.TTerm Testing.TestCase -testCaseValidateCoreTerm x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "validateCoreTerm"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -testCaseVariableOccursInType :: Phantoms.TTerm Testing.VariableOccursInTypeTestCase -> Phantoms.TTerm Testing.TestCase -testCaseVariableOccursInType x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "variableOccursInType"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) - -testCaseWithMetadata :: Phantoms.TTerm String -> Phantoms.TTerm Testing.TestCase -> Phantoms.TTerm (Maybe String) -> Phantoms.TTerm [Testing.Tag] -> Phantoms.TTerm Testing.TestCaseWithMetadata -testCaseWithMetadata name case_ description tags = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm name)}, - Core.Field { - Core.fieldName = (Core.Name "case"), - Core.fieldTerm = (Phantoms.unTTerm case_)}, - Core.Field { - Core.fieldName = (Core.Name "description"), - Core.fieldTerm = (Phantoms.unTTerm description)}, - Core.Field { - Core.fieldName = (Core.Name "tags"), - Core.fieldTerm = (Phantoms.unTTerm tags)}]})) - -testCaseWithMetadataCase :: Phantoms.TTerm Testing.TestCaseWithMetadata -> Phantoms.TTerm Testing.TestCase -testCaseWithMetadataCase x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"), - Core.projectionField = (Core.Name "case")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -testCaseWithMetadataDescription :: Phantoms.TTerm Testing.TestCaseWithMetadata -> Phantoms.TTerm (Maybe String) -testCaseWithMetadataDescription x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"), - Core.projectionField = (Core.Name "description")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -testCaseWithMetadataName :: Phantoms.TTerm Testing.TestCaseWithMetadata -> Phantoms.TTerm String -testCaseWithMetadataName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -testCaseWithMetadataTags :: Phantoms.TTerm Testing.TestCaseWithMetadata -> Phantoms.TTerm [Testing.Tag] -testCaseWithMetadataTags x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"), - Core.projectionField = (Core.Name "tags")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -testCaseWithMetadataWithCase :: Phantoms.TTerm Testing.TestCaseWithMetadata -> Phantoms.TTerm Testing.TestCase -> Phantoms.TTerm Testing.TestCaseWithMetadata -testCaseWithMetadataWithCase original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "case"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "description"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"), - Core.projectionField = (Core.Name "description")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "tags"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"), - Core.projectionField = (Core.Name "tags")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -testCaseWithMetadataWithDescription :: Phantoms.TTerm Testing.TestCaseWithMetadata -> Phantoms.TTerm (Maybe String) -> Phantoms.TTerm Testing.TestCaseWithMetadata -testCaseWithMetadataWithDescription original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "case"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"), - Core.projectionField = (Core.Name "case")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "description"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "tags"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"), - Core.projectionField = (Core.Name "tags")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -testCaseWithMetadataWithName :: Phantoms.TTerm Testing.TestCaseWithMetadata -> Phantoms.TTerm String -> Phantoms.TTerm Testing.TestCaseWithMetadata -testCaseWithMetadataWithName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "case"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"), - Core.projectionField = (Core.Name "case")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "description"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"), - Core.projectionField = (Core.Name "description")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "tags"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"), - Core.projectionField = (Core.Name "tags")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -testCaseWithMetadataWithTags :: Phantoms.TTerm Testing.TestCaseWithMetadata -> Phantoms.TTerm [Testing.Tag] -> Phantoms.TTerm Testing.TestCaseWithMetadata -testCaseWithMetadataWithTags original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "case"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"), - Core.projectionField = (Core.Name "case")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "description"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"), - Core.projectionField = (Core.Name "description")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "tags"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -testCodec :: Phantoms.TTerm Coders.LanguageName -> Phantoms.TTerm Module.FileExtension -> Phantoms.TTerm (Core.Term -> Graph.Graph -> Either String String) -> Phantoms.TTerm (Core.Type -> Graph.Graph -> Either String String) -> Phantoms.TTerm (String -> String) -> Phantoms.TTerm (Module.Namespace -> String) -> Phantoms.TTerm String -> Phantoms.TTerm String -> Phantoms.TTerm String -> Phantoms.TTerm String -> Phantoms.TTerm (S.Set Core.Name -> [String]) -> Phantoms.TTerm Testing.TestCodec -testCodec language fileExtension encodeTerm encodeType formatTestName formatModuleName testCaseTemplate testGroupTemplate moduleTemplate importTemplate findImports = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "language"), - Core.fieldTerm = (Phantoms.unTTerm language)}, - Core.Field { - Core.fieldName = (Core.Name "fileExtension"), - Core.fieldTerm = (Phantoms.unTTerm fileExtension)}, - Core.Field { - Core.fieldName = (Core.Name "encodeTerm"), - Core.fieldTerm = (Phantoms.unTTerm encodeTerm)}, - Core.Field { - Core.fieldName = (Core.Name "encodeType"), - Core.fieldTerm = (Phantoms.unTTerm encodeType)}, - Core.Field { - Core.fieldName = (Core.Name "formatTestName"), - Core.fieldTerm = (Phantoms.unTTerm formatTestName)}, - Core.Field { - Core.fieldName = (Core.Name "formatModuleName"), - Core.fieldTerm = (Phantoms.unTTerm formatModuleName)}, - Core.Field { - Core.fieldName = (Core.Name "testCaseTemplate"), - Core.fieldTerm = (Phantoms.unTTerm testCaseTemplate)}, - Core.Field { - Core.fieldName = (Core.Name "testGroupTemplate"), - Core.fieldTerm = (Phantoms.unTTerm testGroupTemplate)}, - Core.Field { - Core.fieldName = (Core.Name "moduleTemplate"), - Core.fieldTerm = (Phantoms.unTTerm moduleTemplate)}, - Core.Field { - Core.fieldName = (Core.Name "importTemplate"), - Core.fieldTerm = (Phantoms.unTTerm importTemplate)}, - Core.Field { - Core.fieldName = (Core.Name "findImports"), - Core.fieldTerm = (Phantoms.unTTerm findImports)}]})) - -testCodecEncodeTerm :: Phantoms.TTerm Testing.TestCodec -> Phantoms.TTerm (Core.Term -> Graph.Graph -> Either String String) -testCodecEncodeTerm x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "encodeTerm")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -testCodecEncodeType :: Phantoms.TTerm Testing.TestCodec -> Phantoms.TTerm (Core.Type -> Graph.Graph -> Either String String) -testCodecEncodeType x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "encodeType")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -testCodecFileExtension :: Phantoms.TTerm Testing.TestCodec -> Phantoms.TTerm Module.FileExtension -testCodecFileExtension x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "fileExtension")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -testCodecFindImports :: Phantoms.TTerm Testing.TestCodec -> Phantoms.TTerm (S.Set Core.Name -> [String]) -testCodecFindImports x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "findImports")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -testCodecFormatModuleName :: Phantoms.TTerm Testing.TestCodec -> Phantoms.TTerm (Module.Namespace -> String) -testCodecFormatModuleName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "formatModuleName")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -testCodecFormatTestName :: Phantoms.TTerm Testing.TestCodec -> Phantoms.TTerm (String -> String) -testCodecFormatTestName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "formatTestName")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -testCodecImportTemplate :: Phantoms.TTerm Testing.TestCodec -> Phantoms.TTerm String -testCodecImportTemplate x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "importTemplate")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -testCodecLanguage :: Phantoms.TTerm Testing.TestCodec -> Phantoms.TTerm Coders.LanguageName -testCodecLanguage x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "language")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -testCodecModuleTemplate :: Phantoms.TTerm Testing.TestCodec -> Phantoms.TTerm String -testCodecModuleTemplate x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "moduleTemplate")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -testCodecTestCaseTemplate :: Phantoms.TTerm Testing.TestCodec -> Phantoms.TTerm String -testCodecTestCaseTemplate x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "testCaseTemplate")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -testCodecTestGroupTemplate :: Phantoms.TTerm Testing.TestCodec -> Phantoms.TTerm String -testCodecTestGroupTemplate x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "testGroupTemplate")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -testCodecWithEncodeTerm :: Phantoms.TTerm Testing.TestCodec -> Phantoms.TTerm (Core.Term -> Graph.Graph -> Either String String) -> Phantoms.TTerm Testing.TestCodec -testCodecWithEncodeTerm original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "language"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "language")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "fileExtension"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "fileExtension")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "encodeTerm"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "encodeType"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "encodeType")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "formatTestName"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "formatTestName")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "formatModuleName"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "formatModuleName")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "testCaseTemplate"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "testCaseTemplate")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "testGroupTemplate"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "testGroupTemplate")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "moduleTemplate"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "moduleTemplate")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "importTemplate"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "importTemplate")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "findImports"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "findImports")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -testCodecWithEncodeType :: Phantoms.TTerm Testing.TestCodec -> Phantoms.TTerm (Core.Type -> Graph.Graph -> Either String String) -> Phantoms.TTerm Testing.TestCodec -testCodecWithEncodeType original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "language"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "language")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "fileExtension"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "fileExtension")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "encodeTerm"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "encodeTerm")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "encodeType"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "formatTestName"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "formatTestName")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "formatModuleName"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "formatModuleName")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "testCaseTemplate"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "testCaseTemplate")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "testGroupTemplate"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "testGroupTemplate")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "moduleTemplate"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "moduleTemplate")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "importTemplate"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "importTemplate")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "findImports"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "findImports")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -testCodecWithFileExtension :: Phantoms.TTerm Testing.TestCodec -> Phantoms.TTerm Module.FileExtension -> Phantoms.TTerm Testing.TestCodec -testCodecWithFileExtension original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "language"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "language")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "fileExtension"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "encodeTerm"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "encodeTerm")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "encodeType"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "encodeType")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "formatTestName"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "formatTestName")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "formatModuleName"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "formatModuleName")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "testCaseTemplate"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "testCaseTemplate")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "testGroupTemplate"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "testGroupTemplate")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "moduleTemplate"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "moduleTemplate")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "importTemplate"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "importTemplate")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "findImports"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "findImports")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -testCodecWithFindImports :: Phantoms.TTerm Testing.TestCodec -> Phantoms.TTerm (S.Set Core.Name -> [String]) -> Phantoms.TTerm Testing.TestCodec -testCodecWithFindImports original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "language"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "language")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "fileExtension"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "fileExtension")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "encodeTerm"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "encodeTerm")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "encodeType"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "encodeType")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "formatTestName"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "formatTestName")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "formatModuleName"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "formatModuleName")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "testCaseTemplate"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "testCaseTemplate")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "testGroupTemplate"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "testGroupTemplate")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "moduleTemplate"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "moduleTemplate")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "importTemplate"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "importTemplate")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "findImports"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -testCodecWithFormatModuleName :: Phantoms.TTerm Testing.TestCodec -> Phantoms.TTerm (Module.Namespace -> String) -> Phantoms.TTerm Testing.TestCodec -testCodecWithFormatModuleName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "language"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "language")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "fileExtension"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "fileExtension")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "encodeTerm"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "encodeTerm")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "encodeType"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "encodeType")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "formatTestName"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "formatTestName")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "formatModuleName"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "testCaseTemplate"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "testCaseTemplate")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "testGroupTemplate"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "testGroupTemplate")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "moduleTemplate"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "moduleTemplate")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "importTemplate"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "importTemplate")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "findImports"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "findImports")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -testCodecWithFormatTestName :: Phantoms.TTerm Testing.TestCodec -> Phantoms.TTerm (String -> String) -> Phantoms.TTerm Testing.TestCodec -testCodecWithFormatTestName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "language"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "language")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "fileExtension"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "fileExtension")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "encodeTerm"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "encodeTerm")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "encodeType"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "encodeType")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "formatTestName"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "formatModuleName"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "formatModuleName")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "testCaseTemplate"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "testCaseTemplate")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "testGroupTemplate"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "testGroupTemplate")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "moduleTemplate"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "moduleTemplate")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "importTemplate"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "importTemplate")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "findImports"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "findImports")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -testCodecWithImportTemplate :: Phantoms.TTerm Testing.TestCodec -> Phantoms.TTerm String -> Phantoms.TTerm Testing.TestCodec -testCodecWithImportTemplate original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "language"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "language")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "fileExtension"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "fileExtension")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "encodeTerm"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "encodeTerm")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "encodeType"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "encodeType")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "formatTestName"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "formatTestName")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "formatModuleName"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "formatModuleName")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "testCaseTemplate"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "testCaseTemplate")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "testGroupTemplate"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "testGroupTemplate")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "moduleTemplate"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "moduleTemplate")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "importTemplate"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "findImports"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "findImports")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -testCodecWithLanguage :: Phantoms.TTerm Testing.TestCodec -> Phantoms.TTerm Coders.LanguageName -> Phantoms.TTerm Testing.TestCodec -testCodecWithLanguage original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "language"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "fileExtension"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "fileExtension")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "encodeTerm"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "encodeTerm")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "encodeType"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "encodeType")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "formatTestName"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "formatTestName")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "formatModuleName"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "formatModuleName")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "testCaseTemplate"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "testCaseTemplate")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "testGroupTemplate"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "testGroupTemplate")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "moduleTemplate"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "moduleTemplate")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "importTemplate"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "importTemplate")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "findImports"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "findImports")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -testCodecWithModuleTemplate :: Phantoms.TTerm Testing.TestCodec -> Phantoms.TTerm String -> Phantoms.TTerm Testing.TestCodec -testCodecWithModuleTemplate original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "language"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "language")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "fileExtension"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "fileExtension")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "encodeTerm"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "encodeTerm")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "encodeType"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "encodeType")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "formatTestName"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "formatTestName")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "formatModuleName"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "formatModuleName")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "testCaseTemplate"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "testCaseTemplate")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "testGroupTemplate"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "testGroupTemplate")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "moduleTemplate"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "importTemplate"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "importTemplate")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "findImports"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "findImports")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -testCodecWithTestCaseTemplate :: Phantoms.TTerm Testing.TestCodec -> Phantoms.TTerm String -> Phantoms.TTerm Testing.TestCodec -testCodecWithTestCaseTemplate original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "language"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "language")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "fileExtension"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "fileExtension")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "encodeTerm"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "encodeTerm")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "encodeType"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "encodeType")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "formatTestName"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "formatTestName")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "formatModuleName"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "formatModuleName")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "testCaseTemplate"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "testGroupTemplate"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "testGroupTemplate")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "moduleTemplate"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "moduleTemplate")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "importTemplate"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "importTemplate")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "findImports"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "findImports")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -testCodecWithTestGroupTemplate :: Phantoms.TTerm Testing.TestCodec -> Phantoms.TTerm String -> Phantoms.TTerm Testing.TestCodec -testCodecWithTestGroupTemplate original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "language"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "language")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "fileExtension"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "fileExtension")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "encodeTerm"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "encodeTerm")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "encodeType"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "encodeType")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "formatTestName"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "formatTestName")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "formatModuleName"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "formatModuleName")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "testCaseTemplate"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "testCaseTemplate")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "testGroupTemplate"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "moduleTemplate"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "moduleTemplate")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "importTemplate"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "importTemplate")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "findImports"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestCodec"), - Core.projectionField = (Core.Name "findImports")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -testGenerator :: Phantoms.TTerm (Module.Module -> Graph.Graph -> Either String (Module.Namespaces a)) -> Phantoms.TTerm (Module.Namespaces a -> Testing.TestCodec) -> Phantoms.TTerm (Module.Module -> Testing.TestGroup -> Graph.Graph -> Either String (String, String)) -> Phantoms.TTerm (Maybe (String -> [Module.Module] -> (String, String))) -> Phantoms.TTerm (Testing.TestGenerator a) -testGenerator namespacesForModule createCodec generateTestFile aggregatorFile = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.TestGenerator"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "namespacesForModule"), - Core.fieldTerm = (Phantoms.unTTerm namespacesForModule)}, - Core.Field { - Core.fieldName = (Core.Name "createCodec"), - Core.fieldTerm = (Phantoms.unTTerm createCodec)}, - Core.Field { - Core.fieldName = (Core.Name "generateTestFile"), - Core.fieldTerm = (Phantoms.unTTerm generateTestFile)}, - Core.Field { - Core.fieldName = (Core.Name "aggregatorFile"), - Core.fieldTerm = (Phantoms.unTTerm aggregatorFile)}]})) - -testGeneratorAggregatorFile :: Phantoms.TTerm (Testing.TestGenerator a) -> Phantoms.TTerm (Maybe (String -> [Module.Module] -> (String, String))) -testGeneratorAggregatorFile x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestGenerator"), - Core.projectionField = (Core.Name "aggregatorFile")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -testGeneratorCreateCodec :: Phantoms.TTerm (Testing.TestGenerator a) -> Phantoms.TTerm (Module.Namespaces a -> Testing.TestCodec) -testGeneratorCreateCodec x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestGenerator"), - Core.projectionField = (Core.Name "createCodec")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -testGeneratorGenerateTestFile :: Phantoms.TTerm (Testing.TestGenerator a) -> Phantoms.TTerm (Module.Module -> Testing.TestGroup -> Graph.Graph -> Either String (String, String)) -testGeneratorGenerateTestFile x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestGenerator"), - Core.projectionField = (Core.Name "generateTestFile")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -testGeneratorNamespacesForModule :: Phantoms.TTerm (Testing.TestGenerator a) -> Phantoms.TTerm (Module.Module -> Graph.Graph -> Either String (Module.Namespaces a)) -testGeneratorNamespacesForModule x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestGenerator"), - Core.projectionField = (Core.Name "namespacesForModule")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -testGeneratorWithAggregatorFile :: Phantoms.TTerm (Testing.TestGenerator a) -> Phantoms.TTerm (Maybe (String -> [Module.Module] -> (String, String))) -> Phantoms.TTerm (Testing.TestGenerator a) -testGeneratorWithAggregatorFile original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.TestGenerator"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "namespacesForModule"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestGenerator"), - Core.projectionField = (Core.Name "namespacesForModule")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "createCodec"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestGenerator"), - Core.projectionField = (Core.Name "createCodec")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "generateTestFile"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestGenerator"), - Core.projectionField = (Core.Name "generateTestFile")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "aggregatorFile"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -testGeneratorWithCreateCodec :: Phantoms.TTerm (Testing.TestGenerator a) -> Phantoms.TTerm (Module.Namespaces a -> Testing.TestCodec) -> Phantoms.TTerm (Testing.TestGenerator a) -testGeneratorWithCreateCodec original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.TestGenerator"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "namespacesForModule"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestGenerator"), - Core.projectionField = (Core.Name "namespacesForModule")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "createCodec"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "generateTestFile"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestGenerator"), - Core.projectionField = (Core.Name "generateTestFile")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "aggregatorFile"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestGenerator"), - Core.projectionField = (Core.Name "aggregatorFile")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -testGeneratorWithGenerateTestFile :: Phantoms.TTerm (Testing.TestGenerator a) -> Phantoms.TTerm (Module.Module -> Testing.TestGroup -> Graph.Graph -> Either String (String, String)) -> Phantoms.TTerm (Testing.TestGenerator a) -testGeneratorWithGenerateTestFile original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.TestGenerator"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "namespacesForModule"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestGenerator"), - Core.projectionField = (Core.Name "namespacesForModule")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "createCodec"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestGenerator"), - Core.projectionField = (Core.Name "createCodec")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "generateTestFile"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "aggregatorFile"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestGenerator"), - Core.projectionField = (Core.Name "aggregatorFile")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -testGeneratorWithNamespacesForModule :: Phantoms.TTerm (Testing.TestGenerator a) -> Phantoms.TTerm (Module.Module -> Graph.Graph -> Either String (Module.Namespaces a)) -> Phantoms.TTerm (Testing.TestGenerator a) -testGeneratorWithNamespacesForModule original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.TestGenerator"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "namespacesForModule"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "createCodec"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestGenerator"), - Core.projectionField = (Core.Name "createCodec")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "generateTestFile"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestGenerator"), - Core.projectionField = (Core.Name "generateTestFile")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "aggregatorFile"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestGenerator"), - Core.projectionField = (Core.Name "aggregatorFile")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -testGroup :: Phantoms.TTerm String -> Phantoms.TTerm (Maybe String) -> Phantoms.TTerm [Testing.TestGroup] -> Phantoms.TTerm [Testing.TestCaseWithMetadata] -> Phantoms.TTerm Testing.TestGroup -testGroup name description subgroups cases = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.TestGroup"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm name)}, - Core.Field { - Core.fieldName = (Core.Name "description"), - Core.fieldTerm = (Phantoms.unTTerm description)}, - Core.Field { - Core.fieldName = (Core.Name "subgroups"), - Core.fieldTerm = (Phantoms.unTTerm subgroups)}, - Core.Field { - Core.fieldName = (Core.Name "cases"), - Core.fieldTerm = (Phantoms.unTTerm cases)}]})) - -testGroupCases :: Phantoms.TTerm Testing.TestGroup -> Phantoms.TTerm [Testing.TestCaseWithMetadata] -testGroupCases x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestGroup"), - Core.projectionField = (Core.Name "cases")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -testGroupDescription :: Phantoms.TTerm Testing.TestGroup -> Phantoms.TTerm (Maybe String) -testGroupDescription x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestGroup"), - Core.projectionField = (Core.Name "description")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -testGroupName :: Phantoms.TTerm Testing.TestGroup -> Phantoms.TTerm String -testGroupName x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestGroup"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -testGroupSubgroups :: Phantoms.TTerm Testing.TestGroup -> Phantoms.TTerm [Testing.TestGroup] -testGroupSubgroups x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestGroup"), - Core.projectionField = (Core.Name "subgroups")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -testGroupWithCases :: Phantoms.TTerm Testing.TestGroup -> Phantoms.TTerm [Testing.TestCaseWithMetadata] -> Phantoms.TTerm Testing.TestGroup -testGroupWithCases original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.TestGroup"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestGroup"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "description"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestGroup"), - Core.projectionField = (Core.Name "description")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "subgroups"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestGroup"), - Core.projectionField = (Core.Name "subgroups")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "cases"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -testGroupWithDescription :: Phantoms.TTerm Testing.TestGroup -> Phantoms.TTerm (Maybe String) -> Phantoms.TTerm Testing.TestGroup -testGroupWithDescription original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.TestGroup"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestGroup"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "description"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "subgroups"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestGroup"), - Core.projectionField = (Core.Name "subgroups")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "cases"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestGroup"), - Core.projectionField = (Core.Name "cases")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -testGroupWithName :: Phantoms.TTerm Testing.TestGroup -> Phantoms.TTerm String -> Phantoms.TTerm Testing.TestGroup -testGroupWithName original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.TestGroup"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "description"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestGroup"), - Core.projectionField = (Core.Name "description")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "subgroups"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestGroup"), - Core.projectionField = (Core.Name "subgroups")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "cases"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestGroup"), - Core.projectionField = (Core.Name "cases")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -testGroupWithSubgroups :: Phantoms.TTerm Testing.TestGroup -> Phantoms.TTerm [Testing.TestGroup] -> Phantoms.TTerm Testing.TestGroup -testGroupWithSubgroups original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.TestGroup"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestGroup"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "description"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestGroup"), - Core.projectionField = (Core.Name "description")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "subgroups"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "cases"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TestGroup"), - Core.projectionField = (Core.Name "cases")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -topologicalSortBindingsTestCase :: Phantoms.TTerm [(Core.Name, Core.Term)] -> Phantoms.TTerm [[(Core.Name, Core.Term)]] -> Phantoms.TTerm Testing.TopologicalSortBindingsTestCase -topologicalSortBindingsTestCase bindings expected = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.TopologicalSortBindingsTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "bindings"), - Core.fieldTerm = (Phantoms.unTTerm bindings)}, - Core.Field { - Core.fieldName = (Core.Name "expected"), - Core.fieldTerm = (Phantoms.unTTerm expected)}]})) - -topologicalSortBindingsTestCaseBindings :: Phantoms.TTerm Testing.TopologicalSortBindingsTestCase -> Phantoms.TTerm [(Core.Name, Core.Term)] -topologicalSortBindingsTestCaseBindings x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TopologicalSortBindingsTestCase"), - Core.projectionField = (Core.Name "bindings")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -topologicalSortBindingsTestCaseExpected :: Phantoms.TTerm Testing.TopologicalSortBindingsTestCase -> Phantoms.TTerm [[(Core.Name, Core.Term)]] -topologicalSortBindingsTestCaseExpected x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TopologicalSortBindingsTestCase"), - Core.projectionField = (Core.Name "expected")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -topologicalSortBindingsTestCaseWithBindings :: Phantoms.TTerm Testing.TopologicalSortBindingsTestCase -> Phantoms.TTerm [(Core.Name, Core.Term)] -> Phantoms.TTerm Testing.TopologicalSortBindingsTestCase -topologicalSortBindingsTestCaseWithBindings original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.TopologicalSortBindingsTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "bindings"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "expected"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TopologicalSortBindingsTestCase"), - Core.projectionField = (Core.Name "expected")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -topologicalSortBindingsTestCaseWithExpected :: Phantoms.TTerm Testing.TopologicalSortBindingsTestCase -> Phantoms.TTerm [[(Core.Name, Core.Term)]] -> Phantoms.TTerm Testing.TopologicalSortBindingsTestCase -topologicalSortBindingsTestCaseWithExpected original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.TopologicalSortBindingsTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "bindings"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TopologicalSortBindingsTestCase"), - Core.projectionField = (Core.Name "bindings")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "expected"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -topologicalSortSCCTestCase :: Phantoms.TTerm [(Int, [Int])] -> Phantoms.TTerm [[Int]] -> Phantoms.TTerm Testing.TopologicalSortSCCTestCase -topologicalSortSCCTestCase adjacencyList expected = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.TopologicalSortSCCTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "adjacencyList"), - Core.fieldTerm = (Phantoms.unTTerm adjacencyList)}, - Core.Field { - Core.fieldName = (Core.Name "expected"), - Core.fieldTerm = (Phantoms.unTTerm expected)}]})) - -topologicalSortSCCTestCaseAdjacencyList :: Phantoms.TTerm Testing.TopologicalSortSCCTestCase -> Phantoms.TTerm [(Int, [Int])] -topologicalSortSCCTestCaseAdjacencyList x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TopologicalSortSCCTestCase"), - Core.projectionField = (Core.Name "adjacencyList")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -topologicalSortSCCTestCaseExpected :: Phantoms.TTerm Testing.TopologicalSortSCCTestCase -> Phantoms.TTerm [[Int]] -topologicalSortSCCTestCaseExpected x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TopologicalSortSCCTestCase"), - Core.projectionField = (Core.Name "expected")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -topologicalSortSCCTestCaseWithAdjacencyList :: Phantoms.TTerm Testing.TopologicalSortSCCTestCase -> Phantoms.TTerm [(Int, [Int])] -> Phantoms.TTerm Testing.TopologicalSortSCCTestCase -topologicalSortSCCTestCaseWithAdjacencyList original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.TopologicalSortSCCTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "adjacencyList"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "expected"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TopologicalSortSCCTestCase"), - Core.projectionField = (Core.Name "expected")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -topologicalSortSCCTestCaseWithExpected :: Phantoms.TTerm Testing.TopologicalSortSCCTestCase -> Phantoms.TTerm [[Int]] -> Phantoms.TTerm Testing.TopologicalSortSCCTestCase -topologicalSortSCCTestCaseWithExpected original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.TopologicalSortSCCTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "adjacencyList"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TopologicalSortSCCTestCase"), - Core.projectionField = (Core.Name "adjacencyList")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "expected"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -topologicalSortTestCase :: Phantoms.TTerm [(Int, [Int])] -> Phantoms.TTerm (Either [[Int]] [Int]) -> Phantoms.TTerm Testing.TopologicalSortTestCase -topologicalSortTestCase adjacencyList expected = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.TopologicalSortTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "adjacencyList"), - Core.fieldTerm = (Phantoms.unTTerm adjacencyList)}, - Core.Field { - Core.fieldName = (Core.Name "expected"), - Core.fieldTerm = (Phantoms.unTTerm expected)}]})) - -topologicalSortTestCaseAdjacencyList :: Phantoms.TTerm Testing.TopologicalSortTestCase -> Phantoms.TTerm [(Int, [Int])] -topologicalSortTestCaseAdjacencyList x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TopologicalSortTestCase"), - Core.projectionField = (Core.Name "adjacencyList")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -topologicalSortTestCaseExpected :: Phantoms.TTerm Testing.TopologicalSortTestCase -> Phantoms.TTerm (Either [[Int]] [Int]) -topologicalSortTestCaseExpected x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TopologicalSortTestCase"), - Core.projectionField = (Core.Name "expected")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -topologicalSortTestCaseWithAdjacencyList :: Phantoms.TTerm Testing.TopologicalSortTestCase -> Phantoms.TTerm [(Int, [Int])] -> Phantoms.TTerm Testing.TopologicalSortTestCase -topologicalSortTestCaseWithAdjacencyList original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.TopologicalSortTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "adjacencyList"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "expected"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TopologicalSortTestCase"), - Core.projectionField = (Core.Name "expected")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -topologicalSortTestCaseWithExpected :: Phantoms.TTerm Testing.TopologicalSortTestCase -> Phantoms.TTerm (Either [[Int]] [Int]) -> Phantoms.TTerm Testing.TopologicalSortTestCase -topologicalSortTestCaseWithExpected original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.TopologicalSortTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "adjacencyList"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TopologicalSortTestCase"), - Core.projectionField = (Core.Name "adjacencyList")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "expected"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -typeCheckingFailureTestCase :: Phantoms.TTerm Core.Term -> Phantoms.TTerm Testing.TypeCheckingFailureTestCase -typeCheckingFailureTestCase input = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.TypeCheckingFailureTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Phantoms.unTTerm input)}]})) - -typeCheckingFailureTestCaseInput :: Phantoms.TTerm Testing.TypeCheckingFailureTestCase -> Phantoms.TTerm Core.Term -typeCheckingFailureTestCaseInput x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TypeCheckingFailureTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -typeCheckingFailureTestCaseWithInput :: Phantoms.TTerm Testing.TypeCheckingFailureTestCase -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Testing.TypeCheckingFailureTestCase -typeCheckingFailureTestCaseWithInput original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.TypeCheckingFailureTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -typeCheckingTestCase :: Phantoms.TTerm Core.Term -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Testing.TypeCheckingTestCase -typeCheckingTestCase input outputTerm outputType = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.TypeCheckingTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Phantoms.unTTerm input)}, - Core.Field { - Core.fieldName = (Core.Name "outputTerm"), - Core.fieldTerm = (Phantoms.unTTerm outputTerm)}, - Core.Field { - Core.fieldName = (Core.Name "outputType"), - Core.fieldTerm = (Phantoms.unTTerm outputType)}]})) - -typeCheckingTestCaseInput :: Phantoms.TTerm Testing.TypeCheckingTestCase -> Phantoms.TTerm Core.Term -typeCheckingTestCaseInput x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TypeCheckingTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -typeCheckingTestCaseOutputTerm :: Phantoms.TTerm Testing.TypeCheckingTestCase -> Phantoms.TTerm Core.Term -typeCheckingTestCaseOutputTerm x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TypeCheckingTestCase"), - Core.projectionField = (Core.Name "outputTerm")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -typeCheckingTestCaseOutputType :: Phantoms.TTerm Testing.TypeCheckingTestCase -> Phantoms.TTerm Core.Type -typeCheckingTestCaseOutputType x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TypeCheckingTestCase"), - Core.projectionField = (Core.Name "outputType")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -typeCheckingTestCaseWithInput :: Phantoms.TTerm Testing.TypeCheckingTestCase -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Testing.TypeCheckingTestCase -typeCheckingTestCaseWithInput original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.TypeCheckingTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "outputTerm"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TypeCheckingTestCase"), - Core.projectionField = (Core.Name "outputTerm")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "outputType"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TypeCheckingTestCase"), - Core.projectionField = (Core.Name "outputType")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -typeCheckingTestCaseWithOutputTerm :: Phantoms.TTerm Testing.TypeCheckingTestCase -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Testing.TypeCheckingTestCase -typeCheckingTestCaseWithOutputTerm original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.TypeCheckingTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TypeCheckingTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "outputTerm"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "outputType"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TypeCheckingTestCase"), - Core.projectionField = (Core.Name "outputType")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -typeCheckingTestCaseWithOutputType :: Phantoms.TTerm Testing.TypeCheckingTestCase -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Testing.TypeCheckingTestCase -typeCheckingTestCaseWithOutputType original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.TypeCheckingTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TypeCheckingTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "outputTerm"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TypeCheckingTestCase"), - Core.projectionField = (Core.Name "outputTerm")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "outputType"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -typeReductionTestCase :: Phantoms.TTerm Core.Type -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Testing.TypeReductionTestCase -typeReductionTestCase input output = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.TypeReductionTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Phantoms.unTTerm input)}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Phantoms.unTTerm output)}]})) - -typeReductionTestCaseInput :: Phantoms.TTerm Testing.TypeReductionTestCase -> Phantoms.TTerm Core.Type -typeReductionTestCaseInput x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TypeReductionTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -typeReductionTestCaseOutput :: Phantoms.TTerm Testing.TypeReductionTestCase -> Phantoms.TTerm Core.Type -typeReductionTestCaseOutput x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TypeReductionTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -typeReductionTestCaseWithInput :: Phantoms.TTerm Testing.TypeReductionTestCase -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Testing.TypeReductionTestCase -typeReductionTestCaseWithInput original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.TypeReductionTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TypeReductionTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -typeReductionTestCaseWithOutput :: Phantoms.TTerm Testing.TypeReductionTestCase -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Testing.TypeReductionTestCase -typeReductionTestCaseWithOutput original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.TypeReductionTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.TypeReductionTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -typeRewriterReplaceStringWithInt32 :: Phantoms.TTerm Testing.TypeRewriter -typeRewriterReplaceStringWithInt32 = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TypeRewriter"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "replaceStringWithInt32"), - Core.fieldTerm = Core.TermUnit}})) - -unTag :: Phantoms.TTerm Testing.Tag -> Phantoms.TTerm String -unTag x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.testing.Tag")))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -unifyTypesTestCase :: Phantoms.TTerm [Core.Name] -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Core.Type -> Phantoms.TTerm (Either String Typing.TypeSubst) -> Phantoms.TTerm Testing.UnifyTypesTestCase -unifyTypesTestCase schemaTypes left right expected = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.UnifyTypesTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "schemaTypes"), - Core.fieldTerm = (Phantoms.unTTerm schemaTypes)}, - Core.Field { - Core.fieldName = (Core.Name "left"), - Core.fieldTerm = (Phantoms.unTTerm left)}, - Core.Field { - Core.fieldName = (Core.Name "right"), - Core.fieldTerm = (Phantoms.unTTerm right)}, - Core.Field { - Core.fieldName = (Core.Name "expected"), - Core.fieldTerm = (Phantoms.unTTerm expected)}]})) - -unifyTypesTestCaseExpected :: Phantoms.TTerm Testing.UnifyTypesTestCase -> Phantoms.TTerm (Either String Typing.TypeSubst) -unifyTypesTestCaseExpected x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.UnifyTypesTestCase"), - Core.projectionField = (Core.Name "expected")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -unifyTypesTestCaseLeft :: Phantoms.TTerm Testing.UnifyTypesTestCase -> Phantoms.TTerm Core.Type -unifyTypesTestCaseLeft x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.UnifyTypesTestCase"), - Core.projectionField = (Core.Name "left")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -unifyTypesTestCaseRight :: Phantoms.TTerm Testing.UnifyTypesTestCase -> Phantoms.TTerm Core.Type -unifyTypesTestCaseRight x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.UnifyTypesTestCase"), - Core.projectionField = (Core.Name "right")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -unifyTypesTestCaseSchemaTypes :: Phantoms.TTerm Testing.UnifyTypesTestCase -> Phantoms.TTerm [Core.Name] -unifyTypesTestCaseSchemaTypes x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.UnifyTypesTestCase"), - Core.projectionField = (Core.Name "schemaTypes")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -unifyTypesTestCaseWithExpected :: Phantoms.TTerm Testing.UnifyTypesTestCase -> Phantoms.TTerm (Either String Typing.TypeSubst) -> Phantoms.TTerm Testing.UnifyTypesTestCase -unifyTypesTestCaseWithExpected original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.UnifyTypesTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "schemaTypes"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.UnifyTypesTestCase"), - Core.projectionField = (Core.Name "schemaTypes")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "left"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.UnifyTypesTestCase"), - Core.projectionField = (Core.Name "left")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "right"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.UnifyTypesTestCase"), - Core.projectionField = (Core.Name "right")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "expected"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -unifyTypesTestCaseWithLeft :: Phantoms.TTerm Testing.UnifyTypesTestCase -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Testing.UnifyTypesTestCase -unifyTypesTestCaseWithLeft original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.UnifyTypesTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "schemaTypes"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.UnifyTypesTestCase"), - Core.projectionField = (Core.Name "schemaTypes")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "left"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "right"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.UnifyTypesTestCase"), - Core.projectionField = (Core.Name "right")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "expected"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.UnifyTypesTestCase"), - Core.projectionField = (Core.Name "expected")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -unifyTypesTestCaseWithRight :: Phantoms.TTerm Testing.UnifyTypesTestCase -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Testing.UnifyTypesTestCase -unifyTypesTestCaseWithRight original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.UnifyTypesTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "schemaTypes"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.UnifyTypesTestCase"), - Core.projectionField = (Core.Name "schemaTypes")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "left"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.UnifyTypesTestCase"), - Core.projectionField = (Core.Name "left")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "right"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "expected"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.UnifyTypesTestCase"), - Core.projectionField = (Core.Name "expected")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -unifyTypesTestCaseWithSchemaTypes :: Phantoms.TTerm Testing.UnifyTypesTestCase -> Phantoms.TTerm [Core.Name] -> Phantoms.TTerm Testing.UnifyTypesTestCase -unifyTypesTestCaseWithSchemaTypes original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.UnifyTypesTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "schemaTypes"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "left"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.UnifyTypesTestCase"), - Core.projectionField = (Core.Name "left")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "right"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.UnifyTypesTestCase"), - Core.projectionField = (Core.Name "right")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "expected"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.UnifyTypesTestCase"), - Core.projectionField = (Core.Name "expected")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -unshadowVariablesTestCase :: Phantoms.TTerm Core.Term -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Testing.UnshadowVariablesTestCase -unshadowVariablesTestCase input output = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.UnshadowVariablesTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Phantoms.unTTerm input)}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Phantoms.unTTerm output)}]})) - -unshadowVariablesTestCaseInput :: Phantoms.TTerm Testing.UnshadowVariablesTestCase -> Phantoms.TTerm Core.Term -unshadowVariablesTestCaseInput x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.UnshadowVariablesTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -unshadowVariablesTestCaseOutput :: Phantoms.TTerm Testing.UnshadowVariablesTestCase -> Phantoms.TTerm Core.Term -unshadowVariablesTestCaseOutput x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.UnshadowVariablesTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -unshadowVariablesTestCaseWithInput :: Phantoms.TTerm Testing.UnshadowVariablesTestCase -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Testing.UnshadowVariablesTestCase -unshadowVariablesTestCaseWithInput original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.UnshadowVariablesTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.UnshadowVariablesTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -unshadowVariablesTestCaseWithOutput :: Phantoms.TTerm Testing.UnshadowVariablesTestCase -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Testing.UnshadowVariablesTestCase -unshadowVariablesTestCaseWithOutput original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.UnshadowVariablesTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.UnshadowVariablesTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -validateCoreTermTestCase :: Phantoms.TTerm Bool -> Phantoms.TTerm Core.Term -> Phantoms.TTerm (Maybe Core_.InvalidTermError) -> Phantoms.TTerm Testing.ValidateCoreTermTestCase -validateCoreTermTestCase typed input output = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.ValidateCoreTermTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typed"), - Core.fieldTerm = (Phantoms.unTTerm typed)}, - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Phantoms.unTTerm input)}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Phantoms.unTTerm output)}]})) - -validateCoreTermTestCaseInput :: Phantoms.TTerm Testing.ValidateCoreTermTestCase -> Phantoms.TTerm Core.Term -validateCoreTermTestCaseInput x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.ValidateCoreTermTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -validateCoreTermTestCaseOutput :: Phantoms.TTerm Testing.ValidateCoreTermTestCase -> Phantoms.TTerm (Maybe Core_.InvalidTermError) -validateCoreTermTestCaseOutput x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.ValidateCoreTermTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -validateCoreTermTestCaseTyped :: Phantoms.TTerm Testing.ValidateCoreTermTestCase -> Phantoms.TTerm Bool -validateCoreTermTestCaseTyped x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.ValidateCoreTermTestCase"), - Core.projectionField = (Core.Name "typed")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -validateCoreTermTestCaseWithInput :: Phantoms.TTerm Testing.ValidateCoreTermTestCase -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Testing.ValidateCoreTermTestCase -validateCoreTermTestCaseWithInput original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.ValidateCoreTermTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typed"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.ValidateCoreTermTestCase"), - Core.projectionField = (Core.Name "typed")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.ValidateCoreTermTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -validateCoreTermTestCaseWithOutput :: Phantoms.TTerm Testing.ValidateCoreTermTestCase -> Phantoms.TTerm (Maybe Core_.InvalidTermError) -> Phantoms.TTerm Testing.ValidateCoreTermTestCase -validateCoreTermTestCaseWithOutput original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.ValidateCoreTermTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typed"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.ValidateCoreTermTestCase"), - Core.projectionField = (Core.Name "typed")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.ValidateCoreTermTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -validateCoreTermTestCaseWithTyped :: Phantoms.TTerm Testing.ValidateCoreTermTestCase -> Phantoms.TTerm Bool -> Phantoms.TTerm Testing.ValidateCoreTermTestCase -validateCoreTermTestCaseWithTyped original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.ValidateCoreTermTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typed"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.ValidateCoreTermTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.ValidateCoreTermTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -variableOccursInTypeTestCase :: Phantoms.TTerm Core.Name -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Bool -> Phantoms.TTerm Testing.VariableOccursInTypeTestCase -variableOccursInTypeTestCase variable type_ expected = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.VariableOccursInTypeTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "variable"), - Core.fieldTerm = (Phantoms.unTTerm variable)}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Phantoms.unTTerm type_)}, - Core.Field { - Core.fieldName = (Core.Name "expected"), - Core.fieldTerm = (Phantoms.unTTerm expected)}]})) - -variableOccursInTypeTestCaseExpected :: Phantoms.TTerm Testing.VariableOccursInTypeTestCase -> Phantoms.TTerm Bool -variableOccursInTypeTestCaseExpected x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.VariableOccursInTypeTestCase"), - Core.projectionField = (Core.Name "expected")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -variableOccursInTypeTestCaseType :: Phantoms.TTerm Testing.VariableOccursInTypeTestCase -> Phantoms.TTerm Core.Type -variableOccursInTypeTestCaseType x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.VariableOccursInTypeTestCase"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -variableOccursInTypeTestCaseVariable :: Phantoms.TTerm Testing.VariableOccursInTypeTestCase -> Phantoms.TTerm Core.Name -variableOccursInTypeTestCaseVariable x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.VariableOccursInTypeTestCase"), - Core.projectionField = (Core.Name "variable")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -variableOccursInTypeTestCaseWithExpected :: Phantoms.TTerm Testing.VariableOccursInTypeTestCase -> Phantoms.TTerm Bool -> Phantoms.TTerm Testing.VariableOccursInTypeTestCase -variableOccursInTypeTestCaseWithExpected original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.VariableOccursInTypeTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "variable"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.VariableOccursInTypeTestCase"), - Core.projectionField = (Core.Name "variable")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.VariableOccursInTypeTestCase"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "expected"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -variableOccursInTypeTestCaseWithType :: Phantoms.TTerm Testing.VariableOccursInTypeTestCase -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Testing.VariableOccursInTypeTestCase -variableOccursInTypeTestCaseWithType original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.VariableOccursInTypeTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "variable"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.VariableOccursInTypeTestCase"), - Core.projectionField = (Core.Name "variable")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "expected"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.VariableOccursInTypeTestCase"), - Core.projectionField = (Core.Name "expected")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -variableOccursInTypeTestCaseWithVariable :: Phantoms.TTerm Testing.VariableOccursInTypeTestCase -> Phantoms.TTerm Core.Name -> Phantoms.TTerm Testing.VariableOccursInTypeTestCase -variableOccursInTypeTestCaseWithVariable original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.VariableOccursInTypeTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "variable"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.VariableOccursInTypeTestCase"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "expected"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.VariableOccursInTypeTestCase"), - Core.projectionField = (Core.Name "expected")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -writerTestCase :: Phantoms.TTerm a -> Phantoms.TTerm String -> Phantoms.TTerm (Testing.WriterTestCase a) -writerTestCase input output = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.WriterTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Phantoms.unTTerm input)}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Phantoms.unTTerm output)}]})) - -writerTestCaseInput :: Phantoms.TTerm (Testing.WriterTestCase a) -> Phantoms.TTerm a -writerTestCaseInput x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.WriterTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -writerTestCaseOutput :: Phantoms.TTerm (Testing.WriterTestCase a) -> Phantoms.TTerm String -writerTestCaseOutput x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.WriterTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -writerTestCaseWithInput :: Phantoms.TTerm (Testing.WriterTestCase a) -> Phantoms.TTerm a -> Phantoms.TTerm (Testing.WriterTestCase a) -writerTestCaseWithInput original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.WriterTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.WriterTestCase"), - Core.projectionField = (Core.Name "output")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -writerTestCaseWithOutput :: Phantoms.TTerm (Testing.WriterTestCase a) -> Phantoms.TTerm String -> Phantoms.TTerm (Testing.WriterTestCase a) -writerTestCaseWithOutput original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.WriterTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.testing.WriterTestCase"), - Core.projectionField = (Core.Name "input")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) diff --git a/src/gen-main/haskell/Hydra/Dsl/Topology.hs b/src/gen-main/haskell/Hydra/Dsl/Topology.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Dsl/Topology.hs +++ /dev/null @@ -1,411 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | DSL functions for hydra.topology - -module Hydra.Dsl.Topology where - -import qualified Hydra.Core as Core -import qualified Hydra.Phantoms as Phantoms -import qualified Hydra.Topology as Topology -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -orderingIsomorphism :: Phantoms.TTerm ([a] -> [a]) -> Phantoms.TTerm ([a] -> [a]) -> Phantoms.TTerm (Topology.OrderingIsomorphism a) -orderingIsomorphism encode decode = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.topology.OrderingIsomorphism"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "encode"), - Core.fieldTerm = (Phantoms.unTTerm encode)}, - Core.Field { - Core.fieldName = (Core.Name "decode"), - Core.fieldTerm = (Phantoms.unTTerm decode)}]})) - -orderingIsomorphismDecode :: Phantoms.TTerm (Topology.OrderingIsomorphism a) -> Phantoms.TTerm ([a] -> [a]) -orderingIsomorphismDecode x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.topology.OrderingIsomorphism"), - Core.projectionField = (Core.Name "decode")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -orderingIsomorphismEncode :: Phantoms.TTerm (Topology.OrderingIsomorphism a) -> Phantoms.TTerm ([a] -> [a]) -orderingIsomorphismEncode x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.topology.OrderingIsomorphism"), - Core.projectionField = (Core.Name "encode")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -orderingIsomorphismWithDecode :: Phantoms.TTerm (Topology.OrderingIsomorphism a) -> Phantoms.TTerm ([a] -> [a]) -> Phantoms.TTerm (Topology.OrderingIsomorphism a) -orderingIsomorphismWithDecode original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.topology.OrderingIsomorphism"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "encode"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.topology.OrderingIsomorphism"), - Core.projectionField = (Core.Name "encode")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "decode"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -orderingIsomorphismWithEncode :: Phantoms.TTerm (Topology.OrderingIsomorphism a) -> Phantoms.TTerm ([a] -> [a]) -> Phantoms.TTerm (Topology.OrderingIsomorphism a) -orderingIsomorphismWithEncode original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.topology.OrderingIsomorphism"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "encode"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "decode"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.topology.OrderingIsomorphism"), - Core.projectionField = (Core.Name "decode")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -tarjanState :: Phantoms.TTerm Int -> Phantoms.TTerm (M.Map Topology.Vertex Int) -> Phantoms.TTerm (M.Map Topology.Vertex Int) -> Phantoms.TTerm [Topology.Vertex] -> Phantoms.TTerm (S.Set Topology.Vertex) -> Phantoms.TTerm [[Topology.Vertex]] -> Phantoms.TTerm Topology.TarjanState -tarjanState counter indices lowLinks stack onStack sccs = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.topology.TarjanState"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "counter"), - Core.fieldTerm = (Phantoms.unTTerm counter)}, - Core.Field { - Core.fieldName = (Core.Name "indices"), - Core.fieldTerm = (Phantoms.unTTerm indices)}, - Core.Field { - Core.fieldName = (Core.Name "lowLinks"), - Core.fieldTerm = (Phantoms.unTTerm lowLinks)}, - Core.Field { - Core.fieldName = (Core.Name "stack"), - Core.fieldTerm = (Phantoms.unTTerm stack)}, - Core.Field { - Core.fieldName = (Core.Name "onStack"), - Core.fieldTerm = (Phantoms.unTTerm onStack)}, - Core.Field { - Core.fieldName = (Core.Name "sccs"), - Core.fieldTerm = (Phantoms.unTTerm sccs)}]})) - -tarjanStateCounter :: Phantoms.TTerm Topology.TarjanState -> Phantoms.TTerm Int -tarjanStateCounter x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"), - Core.projectionField = (Core.Name "counter")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -tarjanStateIndices :: Phantoms.TTerm Topology.TarjanState -> Phantoms.TTerm (M.Map Topology.Vertex Int) -tarjanStateIndices x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"), - Core.projectionField = (Core.Name "indices")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -tarjanStateLowLinks :: Phantoms.TTerm Topology.TarjanState -> Phantoms.TTerm (M.Map Topology.Vertex Int) -tarjanStateLowLinks x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"), - Core.projectionField = (Core.Name "lowLinks")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -tarjanStateOnStack :: Phantoms.TTerm Topology.TarjanState -> Phantoms.TTerm (S.Set Topology.Vertex) -tarjanStateOnStack x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"), - Core.projectionField = (Core.Name "onStack")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -tarjanStateSccs :: Phantoms.TTerm Topology.TarjanState -> Phantoms.TTerm [[Topology.Vertex]] -tarjanStateSccs x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"), - Core.projectionField = (Core.Name "sccs")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -tarjanStateStack :: Phantoms.TTerm Topology.TarjanState -> Phantoms.TTerm [Topology.Vertex] -tarjanStateStack x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"), - Core.projectionField = (Core.Name "stack")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -tarjanStateWithCounter :: Phantoms.TTerm Topology.TarjanState -> Phantoms.TTerm Int -> Phantoms.TTerm Topology.TarjanState -tarjanStateWithCounter original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.topology.TarjanState"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "counter"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "indices"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"), - Core.projectionField = (Core.Name "indices")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "lowLinks"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"), - Core.projectionField = (Core.Name "lowLinks")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "stack"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"), - Core.projectionField = (Core.Name "stack")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "onStack"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"), - Core.projectionField = (Core.Name "onStack")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "sccs"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"), - Core.projectionField = (Core.Name "sccs")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -tarjanStateWithIndices :: Phantoms.TTerm Topology.TarjanState -> Phantoms.TTerm (M.Map Topology.Vertex Int) -> Phantoms.TTerm Topology.TarjanState -tarjanStateWithIndices original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.topology.TarjanState"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "counter"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"), - Core.projectionField = (Core.Name "counter")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "indices"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "lowLinks"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"), - Core.projectionField = (Core.Name "lowLinks")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "stack"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"), - Core.projectionField = (Core.Name "stack")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "onStack"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"), - Core.projectionField = (Core.Name "onStack")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "sccs"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"), - Core.projectionField = (Core.Name "sccs")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -tarjanStateWithLowLinks :: Phantoms.TTerm Topology.TarjanState -> Phantoms.TTerm (M.Map Topology.Vertex Int) -> Phantoms.TTerm Topology.TarjanState -tarjanStateWithLowLinks original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.topology.TarjanState"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "counter"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"), - Core.projectionField = (Core.Name "counter")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "indices"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"), - Core.projectionField = (Core.Name "indices")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "lowLinks"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "stack"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"), - Core.projectionField = (Core.Name "stack")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "onStack"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"), - Core.projectionField = (Core.Name "onStack")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "sccs"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"), - Core.projectionField = (Core.Name "sccs")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -tarjanStateWithOnStack :: Phantoms.TTerm Topology.TarjanState -> Phantoms.TTerm (S.Set Topology.Vertex) -> Phantoms.TTerm Topology.TarjanState -tarjanStateWithOnStack original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.topology.TarjanState"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "counter"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"), - Core.projectionField = (Core.Name "counter")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "indices"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"), - Core.projectionField = (Core.Name "indices")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "lowLinks"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"), - Core.projectionField = (Core.Name "lowLinks")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "stack"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"), - Core.projectionField = (Core.Name "stack")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "onStack"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "sccs"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"), - Core.projectionField = (Core.Name "sccs")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -tarjanStateWithSccs :: Phantoms.TTerm Topology.TarjanState -> Phantoms.TTerm [[Topology.Vertex]] -> Phantoms.TTerm Topology.TarjanState -tarjanStateWithSccs original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.topology.TarjanState"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "counter"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"), - Core.projectionField = (Core.Name "counter")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "indices"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"), - Core.projectionField = (Core.Name "indices")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "lowLinks"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"), - Core.projectionField = (Core.Name "lowLinks")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "stack"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"), - Core.projectionField = (Core.Name "stack")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "onStack"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"), - Core.projectionField = (Core.Name "onStack")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "sccs"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -tarjanStateWithStack :: Phantoms.TTerm Topology.TarjanState -> Phantoms.TTerm [Topology.Vertex] -> Phantoms.TTerm Topology.TarjanState -tarjanStateWithStack original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.topology.TarjanState"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "counter"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"), - Core.projectionField = (Core.Name "counter")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "indices"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"), - Core.projectionField = (Core.Name "indices")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "lowLinks"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"), - Core.projectionField = (Core.Name "lowLinks")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "stack"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "onStack"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"), - Core.projectionField = (Core.Name "onStack")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "sccs"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"), - Core.projectionField = (Core.Name "sccs")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) diff --git a/src/gen-main/haskell/Hydra/Dsl/Typing.hs b/src/gen-main/haskell/Hydra/Dsl/Typing.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Dsl/Typing.hs +++ /dev/null @@ -1,834 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | DSL functions for hydra.typing - -module Hydra.Dsl.Typing where - -import qualified Hydra.Context as Context -import qualified Hydra.Core as Core -import qualified Hydra.Phantoms as Phantoms -import qualified Hydra.Typing as Typing -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -functionStructure :: Phantoms.TTerm [Core.Name] -> Phantoms.TTerm [Core.Name] -> Phantoms.TTerm [Core.Binding] -> Phantoms.TTerm Core.Term -> Phantoms.TTerm [Core.Type] -> Phantoms.TTerm (Maybe Core.Type) -> Phantoms.TTerm env -> Phantoms.TTerm (Typing.FunctionStructure env) -functionStructure typeParams params bindings body domains codomain environment = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeParams"), - Core.fieldTerm = (Phantoms.unTTerm typeParams)}, - Core.Field { - Core.fieldName = (Core.Name "params"), - Core.fieldTerm = (Phantoms.unTTerm params)}, - Core.Field { - Core.fieldName = (Core.Name "bindings"), - Core.fieldTerm = (Phantoms.unTTerm bindings)}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Phantoms.unTTerm body)}, - Core.Field { - Core.fieldName = (Core.Name "domains"), - Core.fieldTerm = (Phantoms.unTTerm domains)}, - Core.Field { - Core.fieldName = (Core.Name "codomain"), - Core.fieldTerm = (Phantoms.unTTerm codomain)}, - Core.Field { - Core.fieldName = (Core.Name "environment"), - Core.fieldTerm = (Phantoms.unTTerm environment)}]})) - -functionStructureBindings :: Phantoms.TTerm (Typing.FunctionStructure env) -> Phantoms.TTerm [Core.Binding] -functionStructureBindings x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.projectionField = (Core.Name "bindings")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -functionStructureBody :: Phantoms.TTerm (Typing.FunctionStructure env) -> Phantoms.TTerm Core.Term -functionStructureBody x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.projectionField = (Core.Name "body")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -functionStructureCodomain :: Phantoms.TTerm (Typing.FunctionStructure env) -> Phantoms.TTerm (Maybe Core.Type) -functionStructureCodomain x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.projectionField = (Core.Name "codomain")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -functionStructureDomains :: Phantoms.TTerm (Typing.FunctionStructure env) -> Phantoms.TTerm [Core.Type] -functionStructureDomains x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.projectionField = (Core.Name "domains")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -functionStructureEnvironment :: Phantoms.TTerm (Typing.FunctionStructure env) -> Phantoms.TTerm env -functionStructureEnvironment x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.projectionField = (Core.Name "environment")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -functionStructureParams :: Phantoms.TTerm (Typing.FunctionStructure env) -> Phantoms.TTerm [Core.Name] -functionStructureParams x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.projectionField = (Core.Name "params")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -functionStructureTypeParams :: Phantoms.TTerm (Typing.FunctionStructure env) -> Phantoms.TTerm [Core.Name] -functionStructureTypeParams x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.projectionField = (Core.Name "typeParams")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -functionStructureWithBindings :: Phantoms.TTerm (Typing.FunctionStructure env) -> Phantoms.TTerm [Core.Binding] -> Phantoms.TTerm (Typing.FunctionStructure env) -functionStructureWithBindings original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeParams"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.projectionField = (Core.Name "typeParams")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "params"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.projectionField = (Core.Name "params")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "bindings"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.projectionField = (Core.Name "body")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "domains"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.projectionField = (Core.Name "domains")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "codomain"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.projectionField = (Core.Name "codomain")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "environment"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.projectionField = (Core.Name "environment")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -functionStructureWithBody :: Phantoms.TTerm (Typing.FunctionStructure env) -> Phantoms.TTerm Core.Term -> Phantoms.TTerm (Typing.FunctionStructure env) -functionStructureWithBody original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeParams"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.projectionField = (Core.Name "typeParams")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "params"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.projectionField = (Core.Name "params")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "bindings"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.projectionField = (Core.Name "bindings")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "domains"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.projectionField = (Core.Name "domains")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "codomain"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.projectionField = (Core.Name "codomain")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "environment"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.projectionField = (Core.Name "environment")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -functionStructureWithCodomain :: Phantoms.TTerm (Typing.FunctionStructure env) -> Phantoms.TTerm (Maybe Core.Type) -> Phantoms.TTerm (Typing.FunctionStructure env) -functionStructureWithCodomain original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeParams"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.projectionField = (Core.Name "typeParams")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "params"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.projectionField = (Core.Name "params")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "bindings"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.projectionField = (Core.Name "bindings")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.projectionField = (Core.Name "body")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "domains"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.projectionField = (Core.Name "domains")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "codomain"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "environment"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.projectionField = (Core.Name "environment")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -functionStructureWithDomains :: Phantoms.TTerm (Typing.FunctionStructure env) -> Phantoms.TTerm [Core.Type] -> Phantoms.TTerm (Typing.FunctionStructure env) -functionStructureWithDomains original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeParams"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.projectionField = (Core.Name "typeParams")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "params"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.projectionField = (Core.Name "params")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "bindings"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.projectionField = (Core.Name "bindings")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.projectionField = (Core.Name "body")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "domains"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "codomain"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.projectionField = (Core.Name "codomain")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "environment"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.projectionField = (Core.Name "environment")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -functionStructureWithEnvironment :: Phantoms.TTerm (Typing.FunctionStructure env) -> Phantoms.TTerm env -> Phantoms.TTerm (Typing.FunctionStructure env) -functionStructureWithEnvironment original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeParams"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.projectionField = (Core.Name "typeParams")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "params"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.projectionField = (Core.Name "params")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "bindings"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.projectionField = (Core.Name "bindings")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.projectionField = (Core.Name "body")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "domains"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.projectionField = (Core.Name "domains")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "codomain"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.projectionField = (Core.Name "codomain")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "environment"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -functionStructureWithParams :: Phantoms.TTerm (Typing.FunctionStructure env) -> Phantoms.TTerm [Core.Name] -> Phantoms.TTerm (Typing.FunctionStructure env) -functionStructureWithParams original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeParams"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.projectionField = (Core.Name "typeParams")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "params"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "bindings"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.projectionField = (Core.Name "bindings")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.projectionField = (Core.Name "body")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "domains"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.projectionField = (Core.Name "domains")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "codomain"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.projectionField = (Core.Name "codomain")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "environment"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.projectionField = (Core.Name "environment")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -functionStructureWithTypeParams :: Phantoms.TTerm (Typing.FunctionStructure env) -> Phantoms.TTerm [Core.Name] -> Phantoms.TTerm (Typing.FunctionStructure env) -functionStructureWithTypeParams original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeParams"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "params"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.projectionField = (Core.Name "params")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "bindings"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.projectionField = (Core.Name "bindings")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.projectionField = (Core.Name "body")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "domains"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.projectionField = (Core.Name "domains")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "codomain"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.projectionField = (Core.Name "codomain")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "environment"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.projectionField = (Core.Name "environment")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -inferenceResult :: Phantoms.TTerm Core.Term -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Typing.TypeSubst -> Phantoms.TTerm (M.Map Core.Name Core.TypeVariableMetadata) -> Phantoms.TTerm Context.Context -> Phantoms.TTerm Typing.InferenceResult -inferenceResult term type_ subst classConstraints context = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.typing.InferenceResult"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Phantoms.unTTerm term)}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Phantoms.unTTerm type_)}, - Core.Field { - Core.fieldName = (Core.Name "subst"), - Core.fieldTerm = (Phantoms.unTTerm subst)}, - Core.Field { - Core.fieldName = (Core.Name "classConstraints"), - Core.fieldTerm = (Phantoms.unTTerm classConstraints)}, - Core.Field { - Core.fieldName = (Core.Name "context"), - Core.fieldTerm = (Phantoms.unTTerm context)}]})) - -inferenceResultClassConstraints :: Phantoms.TTerm Typing.InferenceResult -> Phantoms.TTerm (M.Map Core.Name Core.TypeVariableMetadata) -inferenceResultClassConstraints x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"), - Core.projectionField = (Core.Name "classConstraints")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -inferenceResultContext :: Phantoms.TTerm Typing.InferenceResult -> Phantoms.TTerm Context.Context -inferenceResultContext x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"), - Core.projectionField = (Core.Name "context")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -inferenceResultSubst :: Phantoms.TTerm Typing.InferenceResult -> Phantoms.TTerm Typing.TypeSubst -inferenceResultSubst x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"), - Core.projectionField = (Core.Name "subst")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -inferenceResultTerm :: Phantoms.TTerm Typing.InferenceResult -> Phantoms.TTerm Core.Term -inferenceResultTerm x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"), - Core.projectionField = (Core.Name "term")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -inferenceResultType :: Phantoms.TTerm Typing.InferenceResult -> Phantoms.TTerm Core.Type -inferenceResultType x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -inferenceResultWithClassConstraints :: Phantoms.TTerm Typing.InferenceResult -> Phantoms.TTerm (M.Map Core.Name Core.TypeVariableMetadata) -> Phantoms.TTerm Typing.InferenceResult -inferenceResultWithClassConstraints original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.typing.InferenceResult"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"), - Core.projectionField = (Core.Name "term")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "subst"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"), - Core.projectionField = (Core.Name "subst")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "classConstraints"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "context"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"), - Core.projectionField = (Core.Name "context")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -inferenceResultWithContext :: Phantoms.TTerm Typing.InferenceResult -> Phantoms.TTerm Context.Context -> Phantoms.TTerm Typing.InferenceResult -inferenceResultWithContext original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.typing.InferenceResult"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"), - Core.projectionField = (Core.Name "term")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "subst"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"), - Core.projectionField = (Core.Name "subst")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "classConstraints"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"), - Core.projectionField = (Core.Name "classConstraints")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "context"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -inferenceResultWithSubst :: Phantoms.TTerm Typing.InferenceResult -> Phantoms.TTerm Typing.TypeSubst -> Phantoms.TTerm Typing.InferenceResult -inferenceResultWithSubst original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.typing.InferenceResult"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"), - Core.projectionField = (Core.Name "term")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "subst"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "classConstraints"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"), - Core.projectionField = (Core.Name "classConstraints")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "context"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"), - Core.projectionField = (Core.Name "context")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -inferenceResultWithTerm :: Phantoms.TTerm Typing.InferenceResult -> Phantoms.TTerm Core.Term -> Phantoms.TTerm Typing.InferenceResult -inferenceResultWithTerm original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.typing.InferenceResult"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"), - Core.projectionField = (Core.Name "type")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "subst"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"), - Core.projectionField = (Core.Name "subst")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "classConstraints"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"), - Core.projectionField = (Core.Name "classConstraints")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "context"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"), - Core.projectionField = (Core.Name "context")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -inferenceResultWithType :: Phantoms.TTerm Typing.InferenceResult -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Typing.InferenceResult -inferenceResultWithType original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.typing.InferenceResult"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"), - Core.projectionField = (Core.Name "term")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "subst"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"), - Core.projectionField = (Core.Name "subst")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "classConstraints"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"), - Core.projectionField = (Core.Name "classConstraints")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "context"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"), - Core.projectionField = (Core.Name "context")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -termSubst :: Phantoms.TTerm (M.Map Core.Name Core.Term) -> Phantoms.TTerm Typing.TermSubst -termSubst x = - Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.typing.TermSubst"), - Core.wrappedTermBody = (Phantoms.unTTerm x)})) - -typeConstraint :: Phantoms.TTerm Core.Type -> Phantoms.TTerm Core.Type -> Phantoms.TTerm String -> Phantoms.TTerm Typing.TypeConstraint -typeConstraint left right comment = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.typing.TypeConstraint"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "left"), - Core.fieldTerm = (Phantoms.unTTerm left)}, - Core.Field { - Core.fieldName = (Core.Name "right"), - Core.fieldTerm = (Phantoms.unTTerm right)}, - Core.Field { - Core.fieldName = (Core.Name "comment"), - Core.fieldTerm = (Phantoms.unTTerm comment)}]})) - -typeConstraintComment :: Phantoms.TTerm Typing.TypeConstraint -> Phantoms.TTerm String -typeConstraintComment x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.TypeConstraint"), - Core.projectionField = (Core.Name "comment")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -typeConstraintLeft :: Phantoms.TTerm Typing.TypeConstraint -> Phantoms.TTerm Core.Type -typeConstraintLeft x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.TypeConstraint"), - Core.projectionField = (Core.Name "left")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -typeConstraintRight :: Phantoms.TTerm Typing.TypeConstraint -> Phantoms.TTerm Core.Type -typeConstraintRight x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.TypeConstraint"), - Core.projectionField = (Core.Name "right")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -typeConstraintWithComment :: Phantoms.TTerm Typing.TypeConstraint -> Phantoms.TTerm String -> Phantoms.TTerm Typing.TypeConstraint -typeConstraintWithComment original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.typing.TypeConstraint"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "left"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.TypeConstraint"), - Core.projectionField = (Core.Name "left")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "right"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.TypeConstraint"), - Core.projectionField = (Core.Name "right")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "comment"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -typeConstraintWithLeft :: Phantoms.TTerm Typing.TypeConstraint -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Typing.TypeConstraint -typeConstraintWithLeft original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.typing.TypeConstraint"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "left"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "right"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.TypeConstraint"), - Core.projectionField = (Core.Name "right")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "comment"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.TypeConstraint"), - Core.projectionField = (Core.Name "comment")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -typeConstraintWithRight :: Phantoms.TTerm Typing.TypeConstraint -> Phantoms.TTerm Core.Type -> Phantoms.TTerm Typing.TypeConstraint -typeConstraintWithRight original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.typing.TypeConstraint"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "left"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.TypeConstraint"), - Core.projectionField = (Core.Name "left")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "right"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "comment"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.typing.TypeConstraint"), - Core.projectionField = (Core.Name "comment")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -typeSubst :: Phantoms.TTerm (M.Map Core.Name Core.Type) -> Phantoms.TTerm Typing.TypeSubst -typeSubst x = - Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.typing.TypeSubst"), - Core.wrappedTermBody = (Phantoms.unTTerm x)})) - -unTermSubst :: Phantoms.TTerm Typing.TermSubst -> Phantoms.TTerm (M.Map Core.Name Core.Term) -unTermSubst x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.typing.TermSubst")))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -unTypeSubst :: Phantoms.TTerm Typing.TypeSubst -> Phantoms.TTerm (M.Map Core.Name Core.Type) -unTypeSubst x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.typing.TypeSubst")))), - Core.applicationArgument = (Phantoms.unTTerm x)})) diff --git a/src/gen-main/haskell/Hydra/Dsl/Util.hs b/src/gen-main/haskell/Hydra/Dsl/Util.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Dsl/Util.hs +++ /dev/null @@ -1,379 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | DSL functions for hydra.util - -module Hydra.Dsl.Util where - -import qualified Hydra.Context as Context -import qualified Hydra.Core as Core -import qualified Hydra.Errors as Errors -import qualified Hydra.Phantoms as Phantoms -import qualified Hydra.Util as Util -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -adapter :: Phantoms.TTerm Bool -> Phantoms.TTerm t1 -> Phantoms.TTerm t2 -> Phantoms.TTerm (Util.Coder v1 v2) -> Phantoms.TTerm (Util.Adapter t1 t2 v1 v2) -adapter isLossy source target coder = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.util.Adapter"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "isLossy"), - Core.fieldTerm = (Phantoms.unTTerm isLossy)}, - Core.Field { - Core.fieldName = (Core.Name "source"), - Core.fieldTerm = (Phantoms.unTTerm source)}, - Core.Field { - Core.fieldName = (Core.Name "target"), - Core.fieldTerm = (Phantoms.unTTerm target)}, - Core.Field { - Core.fieldName = (Core.Name "coder"), - Core.fieldTerm = (Phantoms.unTTerm coder)}]})) - -adapterCoder :: Phantoms.TTerm (Util.Adapter t1 t2 v1 v2) -> Phantoms.TTerm (Util.Coder v1 v2) -adapterCoder x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.util.Adapter"), - Core.projectionField = (Core.Name "coder")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -adapterIsLossy :: Phantoms.TTerm (Util.Adapter t1 t2 v1 v2) -> Phantoms.TTerm Bool -adapterIsLossy x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.util.Adapter"), - Core.projectionField = (Core.Name "isLossy")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -adapterSource :: Phantoms.TTerm (Util.Adapter t1 t2 v1 v2) -> Phantoms.TTerm t1 -adapterSource x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.util.Adapter"), - Core.projectionField = (Core.Name "source")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -adapterTarget :: Phantoms.TTerm (Util.Adapter t1 t2 v1 v2) -> Phantoms.TTerm t2 -adapterTarget x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.util.Adapter"), - Core.projectionField = (Core.Name "target")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -adapterWithCoder :: Phantoms.TTerm (Util.Adapter t1 t2 v1 v2) -> Phantoms.TTerm (Util.Coder v1 v2) -> Phantoms.TTerm (Util.Adapter t1 t2 v1 v2) -adapterWithCoder original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.util.Adapter"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "isLossy"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.util.Adapter"), - Core.projectionField = (Core.Name "isLossy")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "source"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.util.Adapter"), - Core.projectionField = (Core.Name "source")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "target"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.util.Adapter"), - Core.projectionField = (Core.Name "target")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "coder"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -adapterWithIsLossy :: Phantoms.TTerm (Util.Adapter t1 t2 v1 v2) -> Phantoms.TTerm Bool -> Phantoms.TTerm (Util.Adapter t1 t2 v1 v2) -adapterWithIsLossy original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.util.Adapter"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "isLossy"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "source"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.util.Adapter"), - Core.projectionField = (Core.Name "source")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "target"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.util.Adapter"), - Core.projectionField = (Core.Name "target")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "coder"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.util.Adapter"), - Core.projectionField = (Core.Name "coder")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -adapterWithSource :: Phantoms.TTerm (Util.Adapter t1 t2 v1 v2) -> Phantoms.TTerm t1 -> Phantoms.TTerm (Util.Adapter t1 t2 v1 v2) -adapterWithSource original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.util.Adapter"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "isLossy"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.util.Adapter"), - Core.projectionField = (Core.Name "isLossy")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "source"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "target"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.util.Adapter"), - Core.projectionField = (Core.Name "target")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "coder"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.util.Adapter"), - Core.projectionField = (Core.Name "coder")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -adapterWithTarget :: Phantoms.TTerm (Util.Adapter t1 t2 v1 v2) -> Phantoms.TTerm t2 -> Phantoms.TTerm (Util.Adapter t1 t2 v1 v2) -adapterWithTarget original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.util.Adapter"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "isLossy"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.util.Adapter"), - Core.projectionField = (Core.Name "isLossy")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "source"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.util.Adapter"), - Core.projectionField = (Core.Name "source")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "target"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "coder"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.util.Adapter"), - Core.projectionField = (Core.Name "coder")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -bicoder :: Phantoms.TTerm (t1 -> Util.Adapter t1 t2 v1 v2) -> Phantoms.TTerm (t2 -> Util.Adapter t2 t1 v2 v1) -> Phantoms.TTerm (Util.Bicoder t1 t2 v1 v2) -bicoder encode decode = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.util.Bicoder"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "encode"), - Core.fieldTerm = (Phantoms.unTTerm encode)}, - Core.Field { - Core.fieldName = (Core.Name "decode"), - Core.fieldTerm = (Phantoms.unTTerm decode)}]})) - -bicoderDecode :: Phantoms.TTerm (Util.Bicoder t1 t2 v1 v2) -> Phantoms.TTerm (t2 -> Util.Adapter t2 t1 v2 v1) -bicoderDecode x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.util.Bicoder"), - Core.projectionField = (Core.Name "decode")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -bicoderEncode :: Phantoms.TTerm (Util.Bicoder t1 t2 v1 v2) -> Phantoms.TTerm (t1 -> Util.Adapter t1 t2 v1 v2) -bicoderEncode x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.util.Bicoder"), - Core.projectionField = (Core.Name "encode")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -bicoderWithDecode :: Phantoms.TTerm (Util.Bicoder t1 t2 v1 v2) -> Phantoms.TTerm (t2 -> Util.Adapter t2 t1 v2 v1) -> Phantoms.TTerm (Util.Bicoder t1 t2 v1 v2) -bicoderWithDecode original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.util.Bicoder"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "encode"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.util.Bicoder"), - Core.projectionField = (Core.Name "encode")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "decode"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -bicoderWithEncode :: Phantoms.TTerm (Util.Bicoder t1 t2 v1 v2) -> Phantoms.TTerm (t1 -> Util.Adapter t1 t2 v1 v2) -> Phantoms.TTerm (Util.Bicoder t1 t2 v1 v2) -bicoderWithEncode original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.util.Bicoder"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "encode"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "decode"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.util.Bicoder"), - Core.projectionField = (Core.Name "decode")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -caseConventionCamel :: Phantoms.TTerm Util.CaseConvention -caseConventionCamel = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.util.CaseConvention"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "camel"), - Core.fieldTerm = Core.TermUnit}})) - -caseConventionLowerSnake :: Phantoms.TTerm Util.CaseConvention -caseConventionLowerSnake = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.util.CaseConvention"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "lowerSnake"), - Core.fieldTerm = Core.TermUnit}})) - -caseConventionPascal :: Phantoms.TTerm Util.CaseConvention -caseConventionPascal = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.util.CaseConvention"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "pascal"), - Core.fieldTerm = Core.TermUnit}})) - -caseConventionUpperSnake :: Phantoms.TTerm Util.CaseConvention -caseConventionUpperSnake = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.util.CaseConvention"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "upperSnake"), - Core.fieldTerm = Core.TermUnit}})) - -coder :: Phantoms.TTerm (Context.Context -> v1 -> Either (Context.InContext Errors.Error) v2) -> Phantoms.TTerm (Context.Context -> v2 -> Either (Context.InContext Errors.Error) v1) -> Phantoms.TTerm (Util.Coder v1 v2) -coder encode decode = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.util.Coder"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "encode"), - Core.fieldTerm = (Phantoms.unTTerm encode)}, - Core.Field { - Core.fieldName = (Core.Name "decode"), - Core.fieldTerm = (Phantoms.unTTerm decode)}]})) - -coderDecode :: Phantoms.TTerm (Util.Coder v1 v2) -> Phantoms.TTerm (Context.Context -> v2 -> Either (Context.InContext Errors.Error) v1) -coderDecode x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.util.Coder"), - Core.projectionField = (Core.Name "decode")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -coderEncode :: Phantoms.TTerm (Util.Coder v1 v2) -> Phantoms.TTerm (Context.Context -> v1 -> Either (Context.InContext Errors.Error) v2) -coderEncode x = - Phantoms.TTerm (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.util.Coder"), - Core.projectionField = (Core.Name "encode")})))), - Core.applicationArgument = (Phantoms.unTTerm x)})) - -coderWithDecode :: Phantoms.TTerm (Util.Coder v1 v2) -> Phantoms.TTerm (Context.Context -> v2 -> Either (Context.InContext Errors.Error) v1) -> Phantoms.TTerm (Util.Coder v1 v2) -coderWithDecode original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.util.Coder"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "encode"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.util.Coder"), - Core.projectionField = (Core.Name "encode")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}, - Core.Field { - Core.fieldName = (Core.Name "decode"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}]})) - -coderWithEncode :: Phantoms.TTerm (Util.Coder v1 v2) -> Phantoms.TTerm (Context.Context -> v1 -> Either (Context.InContext Errors.Error) v2) -> Phantoms.TTerm (Util.Coder v1 v2) -coderWithEncode original newVal = - Phantoms.TTerm (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.util.Coder"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "encode"), - Core.fieldTerm = (Phantoms.unTTerm newVal)}, - Core.Field { - Core.fieldName = (Core.Name "decode"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.util.Coder"), - Core.projectionField = (Core.Name "decode")})))), - Core.applicationArgument = (Phantoms.unTTerm original)}))}]})) - -comparisonEqualTo :: Phantoms.TTerm Util.Comparison -comparisonEqualTo = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.util.Comparison"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "equalTo"), - Core.fieldTerm = Core.TermUnit}})) - -comparisonGreaterThan :: Phantoms.TTerm Util.Comparison -comparisonGreaterThan = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.util.Comparison"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "greaterThan"), - Core.fieldTerm = Core.TermUnit}})) - -comparisonLessThan :: Phantoms.TTerm Util.Comparison -comparisonLessThan = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.util.Comparison"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "lessThan"), - Core.fieldTerm = Core.TermUnit}})) - -precisionArbitrary :: Phantoms.TTerm Util.Precision -precisionArbitrary = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.util.Precision"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "arbitrary"), - Core.fieldTerm = Core.TermUnit}})) - -precisionBits :: Phantoms.TTerm Int -> Phantoms.TTerm Util.Precision -precisionBits x = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.util.Precision"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "bits"), - Core.fieldTerm = (Phantoms.unTTerm x)}})) diff --git a/src/gen-main/haskell/Hydra/Dsl/Variants.hs b/src/gen-main/haskell/Hydra/Dsl/Variants.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Dsl/Variants.hs +++ /dev/null @@ -1,383 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | DSL functions for hydra.variants - -module Hydra.Dsl.Variants where - -import qualified Hydra.Core as Core -import qualified Hydra.Phantoms as Phantoms -import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -eliminationVariantRecord :: Phantoms.TTerm Variants.EliminationVariant -eliminationVariantRecord = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.EliminationVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = Core.TermUnit}})) - -eliminationVariantUnion :: Phantoms.TTerm Variants.EliminationVariant -eliminationVariantUnion = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.EliminationVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "union"), - Core.fieldTerm = Core.TermUnit}})) - -eliminationVariantWrap :: Phantoms.TTerm Variants.EliminationVariant -eliminationVariantWrap = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.EliminationVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wrap"), - Core.fieldTerm = Core.TermUnit}})) - -functionVariantElimination :: Phantoms.TTerm Variants.FunctionVariant -functionVariantElimination = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.FunctionVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "elimination"), - Core.fieldTerm = Core.TermUnit}})) - -functionVariantLambda :: Phantoms.TTerm Variants.FunctionVariant -functionVariantLambda = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.FunctionVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "lambda"), - Core.fieldTerm = Core.TermUnit}})) - -functionVariantPrimitive :: Phantoms.TTerm Variants.FunctionVariant -functionVariantPrimitive = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.FunctionVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "primitive"), - Core.fieldTerm = Core.TermUnit}})) - -literalVariantBinary :: Phantoms.TTerm Variants.LiteralVariant -literalVariantBinary = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.LiteralVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "binary"), - Core.fieldTerm = Core.TermUnit}})) - -literalVariantBoolean :: Phantoms.TTerm Variants.LiteralVariant -literalVariantBoolean = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.LiteralVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "boolean"), - Core.fieldTerm = Core.TermUnit}})) - -literalVariantFloat :: Phantoms.TTerm Variants.LiteralVariant -literalVariantFloat = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.LiteralVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "float"), - Core.fieldTerm = Core.TermUnit}})) - -literalVariantInteger :: Phantoms.TTerm Variants.LiteralVariant -literalVariantInteger = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.LiteralVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = Core.TermUnit}})) - -literalVariantString :: Phantoms.TTerm Variants.LiteralVariant -literalVariantString = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.LiteralVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = Core.TermUnit}})) - -termVariantAnnotated :: Phantoms.TTerm Variants.TermVariant -termVariantAnnotated = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "annotated"), - Core.fieldTerm = Core.TermUnit}})) - -termVariantApplication :: Phantoms.TTerm Variants.TermVariant -termVariantApplication = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "application"), - Core.fieldTerm = Core.TermUnit}})) - -termVariantEither :: Phantoms.TTerm Variants.TermVariant -termVariantEither = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "either"), - Core.fieldTerm = Core.TermUnit}})) - -termVariantFunction :: Phantoms.TTerm Variants.TermVariant -termVariantFunction = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "function"), - Core.fieldTerm = Core.TermUnit}})) - -termVariantLet :: Phantoms.TTerm Variants.TermVariant -termVariantLet = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "let"), - Core.fieldTerm = Core.TermUnit}})) - -termVariantList :: Phantoms.TTerm Variants.TermVariant -termVariantList = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = Core.TermUnit}})) - -termVariantLiteral :: Phantoms.TTerm Variants.TermVariant -termVariantLiteral = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = Core.TermUnit}})) - -termVariantMap :: Phantoms.TTerm Variants.TermVariant -termVariantMap = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "map"), - Core.fieldTerm = Core.TermUnit}})) - -termVariantMaybe :: Phantoms.TTerm Variants.TermVariant -termVariantMaybe = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "maybe"), - Core.fieldTerm = Core.TermUnit}})) - -termVariantPair :: Phantoms.TTerm Variants.TermVariant -termVariantPair = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "pair"), - Core.fieldTerm = Core.TermUnit}})) - -termVariantRecord :: Phantoms.TTerm Variants.TermVariant -termVariantRecord = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = Core.TermUnit}})) - -termVariantSet :: Phantoms.TTerm Variants.TermVariant -termVariantSet = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "set"), - Core.fieldTerm = Core.TermUnit}})) - -termVariantTypeApplication :: Phantoms.TTerm Variants.TermVariant -termVariantTypeApplication = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "typeApplication"), - Core.fieldTerm = Core.TermUnit}})) - -termVariantTypeLambda :: Phantoms.TTerm Variants.TermVariant -termVariantTypeLambda = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "typeLambda"), - Core.fieldTerm = Core.TermUnit}})) - -termVariantUnion :: Phantoms.TTerm Variants.TermVariant -termVariantUnion = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "union"), - Core.fieldTerm = Core.TermUnit}})) - -termVariantUnit :: Phantoms.TTerm Variants.TermVariant -termVariantUnit = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}})) - -termVariantVariable :: Phantoms.TTerm Variants.TermVariant -termVariantVariable = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "variable"), - Core.fieldTerm = Core.TermUnit}})) - -termVariantWrap :: Phantoms.TTerm Variants.TermVariant -termVariantWrap = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wrap"), - Core.fieldTerm = Core.TermUnit}})) - -typeVariantAnnotated :: Phantoms.TTerm Variants.TypeVariant -typeVariantAnnotated = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "annotated"), - Core.fieldTerm = Core.TermUnit}})) - -typeVariantApplication :: Phantoms.TTerm Variants.TypeVariant -typeVariantApplication = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "application"), - Core.fieldTerm = Core.TermUnit}})) - -typeVariantEither :: Phantoms.TTerm Variants.TypeVariant -typeVariantEither = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "either"), - Core.fieldTerm = Core.TermUnit}})) - -typeVariantForall :: Phantoms.TTerm Variants.TypeVariant -typeVariantForall = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "forall"), - Core.fieldTerm = Core.TermUnit}})) - -typeVariantFunction :: Phantoms.TTerm Variants.TypeVariant -typeVariantFunction = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "function"), - Core.fieldTerm = Core.TermUnit}})) - -typeVariantList :: Phantoms.TTerm Variants.TypeVariant -typeVariantList = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = Core.TermUnit}})) - -typeVariantLiteral :: Phantoms.TTerm Variants.TypeVariant -typeVariantLiteral = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = Core.TermUnit}})) - -typeVariantMap :: Phantoms.TTerm Variants.TypeVariant -typeVariantMap = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "map"), - Core.fieldTerm = Core.TermUnit}})) - -typeVariantMaybe :: Phantoms.TTerm Variants.TypeVariant -typeVariantMaybe = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "maybe"), - Core.fieldTerm = Core.TermUnit}})) - -typeVariantPair :: Phantoms.TTerm Variants.TypeVariant -typeVariantPair = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "pair"), - Core.fieldTerm = Core.TermUnit}})) - -typeVariantRecord :: Phantoms.TTerm Variants.TypeVariant -typeVariantRecord = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = Core.TermUnit}})) - -typeVariantSet :: Phantoms.TTerm Variants.TypeVariant -typeVariantSet = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "set"), - Core.fieldTerm = Core.TermUnit}})) - -typeVariantUnion :: Phantoms.TTerm Variants.TypeVariant -typeVariantUnion = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "union"), - Core.fieldTerm = Core.TermUnit}})) - -typeVariantUnit :: Phantoms.TTerm Variants.TypeVariant -typeVariantUnit = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}})) - -typeVariantVariable :: Phantoms.TTerm Variants.TypeVariant -typeVariantVariable = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "variable"), - Core.fieldTerm = Core.TermUnit}})) - -typeVariantVoid :: Phantoms.TTerm Variants.TypeVariant -typeVariantVoid = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "void"), - Core.fieldTerm = Core.TermUnit}})) - -typeVariantWrap :: Phantoms.TTerm Variants.TypeVariant -typeVariantWrap = - Phantoms.TTerm (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wrap"), - Core.fieldTerm = Core.TermUnit}})) diff --git a/src/gen-main/haskell/Hydra/Dsls.hs b/src/gen-main/haskell/Hydra/Dsls.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Dsls.hs +++ /dev/null @@ -1,561 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Functions for generating domain-specific DSL modules from type modules - -module Hydra.Dsls where - -import qualified Hydra.Annotations as Annotations -import qualified Hydra.Context as Context -import qualified Hydra.Core as Core -import qualified Hydra.Decode.Core as Core_ -import qualified Hydra.Errors as Errors -import qualified Hydra.Formatting as Formatting -import qualified Hydra.Graph as Graph -import qualified Hydra.Lib.Eithers as Eithers -import qualified Hydra.Lib.Equality as Equality -import qualified Hydra.Lib.Lists as Lists -import qualified Hydra.Lib.Logic as Logic -import qualified Hydra.Lib.Maybes as Maybes -import qualified Hydra.Lib.Pairs as Pairs -import qualified Hydra.Lib.Strings as Strings -import qualified Hydra.Module as Module -import qualified Hydra.Names as Names -import qualified Hydra.Rewriting as Rewriting -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | Collect forall type variable names from a type -collectForallVars :: Core.Type -> [Core.Name] -collectForallVars typ = - case typ of - Core.TypeAnnotated v0 -> collectForallVars (Core.annotatedTypeBody v0) - Core.TypeForall v0 -> Lists.cons (Core.forallTypeParameter v0) (collectForallVars (Core.forallTypeBody v0)) - _ -> [] - --- | Deduplicate bindings by appending underscore suffixes to duplicate names -deduplicateBindings :: [Core.Binding] -> [Core.Binding] -deduplicateBindings bindings = - Lists.foldl (\acc -> \b -> - let n = Core.unName (Core.bindingName b) - usedNames = Lists.map (\a -> Core.unName (Core.bindingName a)) acc - uniqueName = findUniqueName n usedNames - in (Lists.concat2 acc [ - Core.Binding { - Core.bindingName = (Core.Name uniqueName), - Core.bindingTerm = (Core.bindingTerm b), - Core.bindingType = (Core.bindingType b)}])) [] bindings - --- | Generate a binding name for a DSL function from a type name -dslBindingName :: Core.Name -> Core.Name -dslBindingName n = - - let parts = Strings.splitOn "." (Core.unName n) - in (Logic.ifElse (Logic.not (Lists.null (Lists.tail parts))) (Logic.ifElse (Equality.equal (Lists.head parts) "hydra") (Core.Name (Strings.intercalate "." (Lists.concat2 [ - "hydra", - "dsl"] (Lists.concat2 (Lists.tail (Lists.init parts)) [ - Formatting.decapitalize (Names.localNameOf n)])))) (Core.Name (Strings.intercalate "." (Lists.concat2 [ - "hydra", - "dsl"] (Lists.concat2 (Lists.init parts) [ - Formatting.decapitalize (Names.localNameOf n)]))))) (Core.Name (Formatting.decapitalize (Names.localNameOf n)))) - --- | Generate a qualified DSL element name from a type name and local element name -dslElementName :: Core.Name -> String -> Core.Name -dslElementName typeName localName = - - let parts = Strings.splitOn "." (Core.unName typeName) - nsParts = Lists.init parts - dslNsParts = - Logic.ifElse (Equality.equal (Lists.head nsParts) "hydra") (Lists.concat2 [ - "hydra", - "dsl"] (Lists.tail nsParts)) (Lists.concat2 [ - "hydra", - "dsl"] nsParts) - in (Core.Name (Strings.intercalate "." (Lists.concat2 dslNsParts [ - localName]))) - --- | Transform a type module into a DSL module -dslModule :: Context.Context -> Graph.Graph -> Module.Module -> Either (Context.InContext Errors.Error) (Maybe Module.Module) -dslModule cx graph mod = - Eithers.bind (filterTypeBindings cx graph (Maybes.cat (Lists.map (\d -> case d of - Module.DefinitionType v0 -> Just (Annotations.typeElement (Module.typeDefinitionName v0) (Module.typeDefinitionType v0)) - _ -> Nothing) (Module.moduleDefinitions mod)))) (\typeBindings -> Logic.ifElse (Lists.null typeBindings) (Right Nothing) (Eithers.bind (Eithers.mapList (\b -> Eithers.bimap (\ic -> Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Errors.unDecodingError (Context.inContextObject ic)))), - Context.inContextContext = (Context.inContextContext ic)}) (\x -> x) (generateBindingsForType cx graph b)) typeBindings) (\dslBindings -> Right (Just (Module.Module { - Module.moduleNamespace = (dslNamespace (Module.moduleNamespace mod)), - Module.moduleDefinitions = (Lists.map (\b -> Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.bindingName b), - Module.termDefinitionTerm = (Core.bindingTerm b), - Module.termDefinitionType = (Core.bindingType b)})) (deduplicateBindings (Lists.concat dslBindings))), - Module.moduleTermDependencies = (Lists.nub (Lists.map dslNamespace (Module.moduleTypeDependencies mod))), - Module.moduleTypeDependencies = (Lists.nub (Lists.concat2 [ - Module.moduleNamespace mod, - (Module.Namespace "hydra.phantoms")] (Module.moduleTypeDependencies mod))), - Module.moduleDescription = (Just (Strings.cat [ - "DSL functions for ", - (Module.unNamespace (Module.moduleNamespace mod))]))}))))) - --- | Generate a DSL module namespace from a source module namespace -dslNamespace :: Module.Namespace -> Module.Namespace -dslNamespace ns = - - let parts = Strings.splitOn "." (Module.unNamespace ns) - in (Logic.ifElse (Equality.equal (Lists.head parts) "hydra") (Module.Namespace (Strings.cat [ - "hydra.dsl.", - (Strings.intercalate "." (Lists.tail parts))])) (Module.Namespace (Strings.cat [ - "hydra.dsl.", - (Module.unNamespace ns)]))) - --- | Build a TypeScheme with TTerm-wrapped parameter and result types -dslTypeScheme :: Core.Type -> [Core.Type] -> Core.Type -> Core.TypeScheme -dslTypeScheme origType paramTypes resultType = - - let typeVars = collectForallVars origType - wrappedResult = - Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.phantoms.TTerm")), - Core.applicationTypeArgument = resultType}) - funType = - Lists.foldr (\paramType -> \acc -> Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.phantoms.TTerm")), - Core.applicationTypeArgument = paramType})), - Core.functionTypeCodomain = acc})) wrappedResult paramTypes - in Core.TypeScheme { - Core.typeSchemeVariables = typeVars, - Core.typeSchemeType = funType, - Core.typeSchemeConstraints = Nothing} - --- | Filter bindings to only DSL-eligible type definitions -filterTypeBindings :: t0 -> t1 -> [Core.Binding] -> Either t2 [Core.Binding] -filterTypeBindings cx graph bindings = - Eithers.map Maybes.cat (Eithers.mapList (isDslEligibleBinding cx graph) (Lists.filter Annotations.isNativeType bindings)) - --- | Find a unique name by appending underscores -findUniqueName :: String -> [String] -> String -findUniqueName candidate usedNames = - Logic.ifElse (Lists.null (Lists.filter (Equality.equal candidate) usedNames)) candidate (findUniqueName (Strings.cat [ - candidate, - "_"]) usedNames) - --- | Generate all DSL bindings for a type binding -generateBindingsForType :: Context.Context -> Graph.Graph -> Core.Binding -> Either (Context.InContext Errors.DecodingError) [Core.Binding] -generateBindingsForType cx graph b = - - let typeName = Core.bindingName b - in (Eithers.bind (Eithers.bimap (\_wc_e -> Context.InContext { - Context.inContextObject = _wc_e, - Context.inContextContext = cx}) (\_wc_a -> _wc_a) (Core_.type_ graph (Core.bindingTerm b))) (\rawType -> - let typ = Rewriting.deannotateTypeParameters (Rewriting.deannotateType rawType) - in (Right (case typ of - Core.TypeRecord v0 -> Lists.concat [ - generateRecordConstructor rawType typeName v0, - (Lists.map (generateRecordAccessor rawType typeName) v0), - (Lists.map (generateRecordWithUpdater rawType typeName v0) v0)] - Core.TypeUnion v0 -> Lists.map (generateUnionInjector rawType typeName) v0 - Core.TypeWrap v0 -> generateWrappedTypeAccessors rawType typeName v0 - _ -> [])))) - --- | Generate a record field accessor function -generateRecordAccessor :: Core.Type -> Core.Name -> Core.FieldType -> Core.Binding -generateRecordAccessor origType typeName ft = - - let fieldName = Core.fieldTypeName ft - accessorLocalName = - Strings.cat [ - Formatting.decapitalize (Names.localNameOf typeName), - (Strings.intercalate "" (Lists.map (\s -> Formatting.capitalize s) (Strings.splitOn "." (Core.unName fieldName))))] - accessorName = dslElementName typeName accessorLocalName - paramDomain = - Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.phantoms.TTerm")), - Core.applicationTypeArgument = (nominalResultType typeName origType)}) - body = - Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = (Just paramDomain), - Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.phantoms.TTerm"), - Core.wrappedTermBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "application"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Application"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "function"), - Core.fieldTerm = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "function"), - Core.fieldTerm = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Function"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "elimination"), - Core.fieldTerm = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Elimination"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Projection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Core.unName typeName)))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Core.unName fieldName)))}))}]}))}}))}}))}}))}, - Core.Field { - Core.fieldName = (Core.Name "argument"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.phantoms.TTerm")))), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}]}))}}))}))})) - ts = dslTypeScheme origType [ - nominalResultType typeName origType] (Core.fieldTypeType ft) - in Core.Binding { - Core.bindingName = accessorName, - Core.bindingTerm = body, - Core.bindingType = (Just ts)} - --- | Generate a record constructor function -generateRecordConstructor :: Core.Type -> Core.Name -> [Core.FieldType] -> [Core.Binding] -generateRecordConstructor origType typeName fieldTypes = - - let dFields = - Lists.map (\ft -> Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Core.unName (Core.fieldTypeName ft))))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.phantoms.TTerm")))), - Core.applicationArgument = (Core.TermVariable (Core.Name (Formatting.decapitalize (Names.localNameOf (Core.fieldTypeName ft)))))}))}]})) fieldTypes - recordTerm = - Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.phantoms.TTerm"), - Core.wrappedTermBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Core.unName typeName)))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList dFields)}]}))}}))}) - paramPairs = - Lists.map (\ft -> (Formatting.decapitalize (Names.localNameOf (Core.fieldTypeName ft)), (Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.phantoms.TTerm")), - Core.applicationTypeArgument = (Core.fieldTypeType ft)})))) fieldTypes - body = - Lists.foldl (\acc -> \pp -> Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name (Pairs.first pp)), - Core.lambdaDomain = (Just (Pairs.second pp)), - Core.lambdaBody = acc}))) recordTerm (Lists.reverse paramPairs) - paramTypes = Lists.map (\ft -> Core.fieldTypeType ft) fieldTypes - resultType = nominalResultType typeName origType - ts = dslTypeScheme origType paramTypes resultType - in [ - Core.Binding { - Core.bindingName = (dslBindingName typeName), - Core.bindingTerm = body, - Core.bindingType = (Just ts)}] - --- | Generate a withXxx record field updater function -generateRecordWithUpdater :: Core.Type -> Core.Name -> [Core.FieldType] -> Core.FieldType -> Core.Binding -generateRecordWithUpdater origType typeName allFields targetField = - - let targetFieldName = Core.fieldTypeName targetField - updaterLocalName = - Strings.cat [ - Formatting.decapitalize (Names.localNameOf typeName), - "With", - (Strings.intercalate "" (Lists.map (\s -> Formatting.capitalize s) (Strings.splitOn "." (Core.unName targetFieldName))))] - updaterName = dslElementName typeName updaterLocalName - dFields = - Lists.map (\ft -> Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Core.unName (Core.fieldTypeName ft))))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Logic.ifElse (Equality.equal (Core.unName (Core.fieldTypeName ft)) (Core.unName targetFieldName)) (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.phantoms.TTerm")))), - Core.applicationArgument = (Core.TermVariable (Core.Name "newVal"))})) (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "application"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Application"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "function"), - Core.fieldTerm = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "function"), - Core.fieldTerm = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Function"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "elimination"), - Core.fieldTerm = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Elimination"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Projection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Core.unName typeName)))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Core.unName (Core.fieldTypeName ft))))}))}]}))}}))}}))}}))}, - Core.Field { - Core.fieldName = (Core.Name "argument"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.phantoms.TTerm")))), - Core.applicationArgument = (Core.TermVariable (Core.Name "original"))}))}]}))}})))}]})) allFields - recDomain = - Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.phantoms.TTerm")), - Core.applicationTypeArgument = (nominalResultType typeName origType)}) - fieldDomain = - Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.phantoms.TTerm")), - Core.applicationTypeArgument = (Core.fieldTypeType targetField)}) - body = - Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "original"), - Core.lambdaDomain = (Just recDomain), - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "newVal"), - Core.lambdaDomain = (Just fieldDomain), - Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.phantoms.TTerm"), - Core.wrappedTermBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Core.unName typeName)))}))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList dFields)}]}))}}))}))})))})) - recType = nominalResultType typeName origType - ts = - dslTypeScheme origType [ - recType, - (Core.fieldTypeType targetField)] recType - in Core.Binding { - Core.bindingName = updaterName, - Core.bindingTerm = body, - Core.bindingType = (Just ts)} - --- | Generate a union injection helper -generateUnionInjector :: Core.Type -> Core.Name -> Core.FieldType -> Core.Binding -generateUnionInjector origType typeName ft = - - let fieldName = Core.fieldTypeName ft - fieldType = Core.fieldTypeType ft - injectorLocalName = - Strings.cat [ - Formatting.decapitalize (Names.localNameOf typeName), - (Strings.intercalate "" (Lists.map (\s -> Formatting.capitalize s) (Strings.splitOn "." (Core.unName fieldName))))] - injectorName = dslElementName typeName injectorLocalName - isUnit = - (\t -> case (Rewriting.deannotateType t) of - Core.TypeUnit -> True - _ -> False) fieldType - dFieldValue = - Logic.ifElse isUnit (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}})) (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.phantoms.TTerm")))), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))})) - injectionTerm = - Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.phantoms.TTerm"), - Core.wrappedTermBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "union"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Core.unName typeName)))}))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Core.unName fieldName)))}))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = dFieldValue}]}))}]}))}}))}) - variantDomain = - Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.phantoms.TTerm")), - Core.applicationTypeArgument = (Core.fieldTypeType ft)}) - body = - Logic.ifElse isUnit injectionTerm (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = (Just variantDomain), - Core.lambdaBody = injectionTerm}))) - unionType = nominalResultType typeName origType - ts = Logic.ifElse isUnit (dslTypeScheme origType [] unionType) (dslTypeScheme origType [ - Core.fieldTypeType ft] unionType) - in Core.Binding { - Core.bindingName = injectorName, - Core.bindingTerm = body, - Core.bindingType = (Just ts)} - --- | Generate wrap/unwrap accessors for a wrapped type -generateWrappedTypeAccessors :: Core.Type -> Core.Name -> Core.Type -> [Core.Binding] -generateWrappedTypeAccessors origType typeName innerType = - - let localName = Names.localNameOf typeName - wrapName = dslElementName typeName (Formatting.decapitalize localName) - unwrapLocalName = - Strings.cat [ - "un", - localName] - unwrapName = dslElementName typeName unwrapLocalName - wrapperType = nominalResultType typeName origType - wrapDomain = - Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.phantoms.TTerm")), - Core.applicationTypeArgument = innerType}) - wrapBody = - Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = (Just wrapDomain), - Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.phantoms.TTerm"), - Core.wrappedTermBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wrap"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Core.unName typeName)))}))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.phantoms.TTerm")))), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}]}))}}))}))})) - unwrapDomain = - Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.phantoms.TTerm")), - Core.applicationTypeArgument = wrapperType}) - unwrapBody = - Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = (Just unwrapDomain), - Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.phantoms.TTerm"), - Core.wrappedTermBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "application"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Application"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "function"), - Core.fieldTerm = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "function"), - Core.fieldTerm = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Function"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "elimination"), - Core.fieldTerm = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Elimination"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wrap"), - Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Core.unName typeName)))}))}}))}}))}}))}, - Core.Field { - Core.fieldName = (Core.Name "argument"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.phantoms.TTerm")))), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}]}))}}))}))})) - wrapTs = dslTypeScheme origType [ - innerType] wrapperType - unwrapTs = dslTypeScheme origType [ - wrapperType] innerType - in [ - Core.Binding { - Core.bindingName = wrapName, - Core.bindingTerm = wrapBody, - Core.bindingType = (Just wrapTs)}, - Core.Binding { - Core.bindingName = unwrapName, - Core.bindingTerm = unwrapBody, - Core.bindingType = (Just unwrapTs)}] - --- | Check if a binding is eligible for DSL generation -isDslEligibleBinding :: t0 -> t1 -> Core.Binding -> Either t2 (Maybe Core.Binding) -isDslEligibleBinding cx graph b = - - let ns = Names.namespaceOf (Core.bindingName b) - in (Logic.ifElse (Equality.equal (Maybes.maybe "" Module.unNamespace ns) "hydra.phantoms") (Right Nothing) (Right (Just b))) - --- | Build the nominal result type with type applications for forall variables -nominalResultType :: Core.Name -> Core.Type -> Core.Type -nominalResultType typeName origType = - - let vars = collectForallVars origType - in (Lists.foldl (\acc -> \v -> Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = acc, - Core.applicationTypeArgument = (Core.TypeVariable v)})) (Core.TypeVariable typeName) vars) diff --git a/src/gen-main/haskell/Hydra/Encode/Ast.hs b/src/gen-main/haskell/Hydra/Encode/Ast.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Encode/Ast.hs +++ /dev/null @@ -1,235 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Term encoders for hydra.ast - -module Hydra.Encode.Ast where - -import qualified Hydra.Ast as Ast -import qualified Hydra.Core as Core -import qualified Hydra.Lib.Lists as Lists -import qualified Hydra.Lib.Maybes as Maybes -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -associativity :: Ast.Associativity -> Core.Term -associativity x = - case x of - Ast.AssociativityNone -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.Associativity"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "none"), - Core.fieldTerm = Core.TermUnit}}) - Ast.AssociativityLeft -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.Associativity"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "left"), - Core.fieldTerm = Core.TermUnit}}) - Ast.AssociativityRight -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.Associativity"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "right"), - Core.fieldTerm = Core.TermUnit}}) - Ast.AssociativityBoth -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.Associativity"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "both"), - Core.fieldTerm = Core.TermUnit}}) - -blockStyle :: Ast.BlockStyle -> Core.Term -blockStyle x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ast.BlockStyle"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "indent"), - Core.fieldTerm = ((\opt -> Core.TermMaybe (Maybes.map (\x -> Core.TermLiteral (Core.LiteralString x)) opt)) (Ast.blockStyleIndent x))}, - Core.Field { - Core.fieldName = (Core.Name "newlineBeforeContent"), - Core.fieldTerm = ((\x -> Core.TermLiteral (Core.LiteralBoolean x)) (Ast.blockStyleNewlineBeforeContent x))}, - Core.Field { - Core.fieldName = (Core.Name "newlineAfterContent"), - Core.fieldTerm = ((\x -> Core.TermLiteral (Core.LiteralBoolean x)) (Ast.blockStyleNewlineAfterContent x))}]}) - -bracketExpr :: Ast.BracketExpr -> Core.Term -bracketExpr x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ast.BracketExpr"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "brackets"), - Core.fieldTerm = (brackets (Ast.bracketExprBrackets x))}, - Core.Field { - Core.fieldName = (Core.Name "enclosed"), - Core.fieldTerm = (expr (Ast.bracketExprEnclosed x))}, - Core.Field { - Core.fieldName = (Core.Name "style"), - Core.fieldTerm = (blockStyle (Ast.bracketExprStyle x))}]}) - -brackets :: Ast.Brackets -> Core.Term -brackets x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ast.Brackets"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "open"), - Core.fieldTerm = (symbol (Ast.bracketsOpen x))}, - Core.Field { - Core.fieldName = (Core.Name "close"), - Core.fieldTerm = (symbol (Ast.bracketsClose x))}]}) - -expr :: Ast.Expr -> Core.Term -expr x = - case x of - Ast.ExprConst v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.Expr"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "const"), - Core.fieldTerm = (symbol v0)}}) - Ast.ExprIndent v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.Expr"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "indent"), - Core.fieldTerm = (indentedExpression v0)}}) - Ast.ExprOp v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.Expr"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "op"), - Core.fieldTerm = (opExpr v0)}}) - Ast.ExprBrackets v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.Expr"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "brackets"), - Core.fieldTerm = (bracketExpr v0)}}) - Ast.ExprSeq v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.Expr"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "seq"), - Core.fieldTerm = (seqExpr v0)}}) - -indentStyle :: Ast.IndentStyle -> Core.Term -indentStyle x = - case x of - Ast.IndentStyleAllLines v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.IndentStyle"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "allLines"), - Core.fieldTerm = (Core.TermLiteral (Core.LiteralString v0))}}) - Ast.IndentStyleSubsequentLines v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.IndentStyle"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "subsequentLines"), - Core.fieldTerm = (Core.TermLiteral (Core.LiteralString v0))}}) - -indentedExpression :: Ast.IndentedExpression -> Core.Term -indentedExpression x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ast.IndentedExpression"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "style"), - Core.fieldTerm = (indentStyle (Ast.indentedExpressionStyle x))}, - Core.Field { - Core.fieldName = (Core.Name "expr"), - Core.fieldTerm = (expr (Ast.indentedExpressionExpr x))}]}) - -op :: Ast.Op -> Core.Term -op x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ast.Op"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "symbol"), - Core.fieldTerm = (symbol (Ast.opSymbol x))}, - Core.Field { - Core.fieldName = (Core.Name "padding"), - Core.fieldTerm = (padding (Ast.opPadding x))}, - Core.Field { - Core.fieldName = (Core.Name "precedence"), - Core.fieldTerm = (precedence (Ast.opPrecedence x))}, - Core.Field { - Core.fieldName = (Core.Name "associativity"), - Core.fieldTerm = (associativity (Ast.opAssociativity x))}]}) - -opExpr :: Ast.OpExpr -> Core.Term -opExpr x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ast.OpExpr"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "op"), - Core.fieldTerm = (op (Ast.opExprOp x))}, - Core.Field { - Core.fieldName = (Core.Name "lhs"), - Core.fieldTerm = (expr (Ast.opExprLhs x))}, - Core.Field { - Core.fieldName = (Core.Name "rhs"), - Core.fieldTerm = (expr (Ast.opExprRhs x))}]}) - -padding :: Ast.Padding -> Core.Term -padding x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ast.Padding"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "left"), - Core.fieldTerm = (ws (Ast.paddingLeft x))}, - Core.Field { - Core.fieldName = (Core.Name "right"), - Core.fieldTerm = (ws (Ast.paddingRight x))}]}) - -precedence :: Ast.Precedence -> Core.Term -precedence x = - Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.ast.Precedence"), - Core.wrappedTermBody = ((\x -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x))) (Ast.unPrecedence x))}) - -seqExpr :: Ast.SeqExpr -> Core.Term -seqExpr x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ast.SeqExpr"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "op"), - Core.fieldTerm = (op (Ast.seqExprOp x))}, - Core.Field { - Core.fieldName = (Core.Name "elements"), - Core.fieldTerm = ((\xs -> Core.TermList (Lists.map expr xs)) (Ast.seqExprElements x))}]}) - -symbol :: Ast.Symbol -> Core.Term -symbol x = - Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.ast.Symbol"), - Core.wrappedTermBody = ((\x -> Core.TermLiteral (Core.LiteralString x)) (Ast.unSymbol x))}) - -ws :: Ast.Ws -> Core.Term -ws x = - case x of - Ast.WsNone -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.Ws"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "none"), - Core.fieldTerm = Core.TermUnit}}) - Ast.WsSpace -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.Ws"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "space"), - Core.fieldTerm = Core.TermUnit}}) - Ast.WsBreak -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.Ws"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "break"), - Core.fieldTerm = Core.TermUnit}}) - Ast.WsBreakAndIndent v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.Ws"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "breakAndIndent"), - Core.fieldTerm = (Core.TermLiteral (Core.LiteralString v0))}}) - Ast.WsDoubleBreak -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.Ws"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "doubleBreak"), - Core.fieldTerm = Core.TermUnit}}) diff --git a/src/gen-main/haskell/Hydra/Encode/Classes.hs b/src/gen-main/haskell/Hydra/Encode/Classes.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Encode/Classes.hs +++ /dev/null @@ -1,28 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Term encoders for hydra.classes - -module Hydra.Encode.Classes where - -import qualified Hydra.Classes as Classes -import qualified Hydra.Core as Core -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -typeClass :: Classes.TypeClass -> Core.Term -typeClass x = - case x of - Classes.TypeClassEquality -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.classes.TypeClass"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "equality"), - Core.fieldTerm = Core.TermUnit}}) - Classes.TypeClassOrdering -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.classes.TypeClass"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "ordering"), - Core.fieldTerm = Core.TermUnit}}) diff --git a/src/gen-main/haskell/Hydra/Encode/Coders.hs b/src/gen-main/haskell/Hydra/Encode/Coders.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Encode/Coders.hs +++ /dev/null @@ -1,48 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Term encoders for hydra.coders - -module Hydra.Encode.Coders where - -import qualified Hydra.Coders as Coders -import qualified Hydra.Core as Core -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -coderDirection :: Coders.CoderDirection -> Core.Term -coderDirection x = - case x of - Coders.CoderDirectionEncode -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.coders.CoderDirection"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "encode"), - Core.fieldTerm = Core.TermUnit}}) - Coders.CoderDirectionDecode -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.coders.CoderDirection"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "decode"), - Core.fieldTerm = Core.TermUnit}}) - -languageName :: Coders.LanguageName -> Core.Term -languageName x = - Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.coders.LanguageName"), - Core.wrappedTermBody = ((\x -> Core.TermLiteral (Core.LiteralString x)) (Coders.unLanguageName x))}) - -traversalOrder :: Coders.TraversalOrder -> Core.Term -traversalOrder x = - case x of - Coders.TraversalOrderPre -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.coders.TraversalOrder"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "pre"), - Core.fieldTerm = Core.TermUnit}}) - Coders.TraversalOrderPost -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.coders.TraversalOrder"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "post"), - Core.fieldTerm = Core.TermUnit}}) diff --git a/src/gen-main/haskell/Hydra/Encode/Context.hs b/src/gen-main/haskell/Hydra/Encode/Context.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Encode/Context.hs +++ /dev/null @@ -1,44 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Term encoders for hydra.context - -module Hydra.Encode.Context where - -import qualified Hydra.Context as Context -import qualified Hydra.Core as Core -import qualified Hydra.Encode.Core as Core_ -import qualified Hydra.Lib.Lists as Lists -import qualified Hydra.Lib.Maps as Maps -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -context :: Context.Context -> Core.Term -context x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.context.Context"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "trace"), - Core.fieldTerm = ((\xs -> Core.TermList (Lists.map (\x -> Core.TermLiteral (Core.LiteralString x)) xs)) (Context.contextTrace x))}, - Core.Field { - Core.fieldName = (Core.Name "messages"), - Core.fieldTerm = ((\xs -> Core.TermList (Lists.map (\x -> Core.TermLiteral (Core.LiteralString x)) xs)) (Context.contextMessages x))}, - Core.Field { - Core.fieldName = (Core.Name "other"), - Core.fieldTerm = ((\m -> Core.TermMap (Maps.bimap Core_.name Core_.term m)) (Context.contextOther x))}]}) - -inContext :: (t0 -> Core.Term) -> Context.InContext t0 -> Core.Term -inContext e x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.context.InContext"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "object"), - Core.fieldTerm = (e (Context.inContextObject x))}, - Core.Field { - Core.fieldName = (Core.Name "context"), - Core.fieldTerm = (context (Context.inContextContext x))}]}) diff --git a/src/gen-main/haskell/Hydra/Encode/Core.hs b/src/gen-main/haskell/Hydra/Encode/Core.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Encode/Core.hs +++ /dev/null @@ -1,725 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Term encoders for hydra.core - -module Hydra.Encode.Core where - -import qualified Hydra.Core as Core -import qualified Hydra.Lib.Eithers as Eithers -import qualified Hydra.Lib.Lists as Lists -import qualified Hydra.Lib.Maps as Maps -import qualified Hydra.Lib.Maybes as Maybes -import qualified Hydra.Lib.Pairs as Pairs -import qualified Hydra.Lib.Sets as Sets -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -annotatedTerm :: Core.AnnotatedTerm -> Core.Term -annotatedTerm x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.AnnotatedTerm"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (term (Core.annotatedTermBody x))}, - Core.Field { - Core.fieldName = (Core.Name "annotation"), - Core.fieldTerm = ((\m -> Core.TermMap (Maps.bimap name term m)) (Core.annotatedTermAnnotation x))}]}) - -annotatedType :: Core.AnnotatedType -> Core.Term -annotatedType x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.AnnotatedType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (type_ (Core.annotatedTypeBody x))}, - Core.Field { - Core.fieldName = (Core.Name "annotation"), - Core.fieldTerm = ((\m -> Core.TermMap (Maps.bimap name term m)) (Core.annotatedTypeAnnotation x))}]}) - -application :: Core.Application -> Core.Term -application x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Application"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "function"), - Core.fieldTerm = (term (Core.applicationFunction x))}, - Core.Field { - Core.fieldName = (Core.Name "argument"), - Core.fieldTerm = (term (Core.applicationArgument x))}]}) - -applicationType :: Core.ApplicationType -> Core.Term -applicationType x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.ApplicationType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "function"), - Core.fieldTerm = (type_ (Core.applicationTypeFunction x))}, - Core.Field { - Core.fieldName = (Core.Name "argument"), - Core.fieldTerm = (type_ (Core.applicationTypeArgument x))}]}) - -binding :: Core.Binding -> Core.Term -binding x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Binding"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (name (Core.bindingName x))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (term (Core.bindingTerm x))}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = ((\opt -> Core.TermMaybe (Maybes.map typeScheme opt)) (Core.bindingType x))}]}) - -caseStatement :: Core.CaseStatement -> Core.Term -caseStatement x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.CaseStatement"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (name (Core.caseStatementTypeName x))}, - Core.Field { - Core.fieldName = (Core.Name "default"), - Core.fieldTerm = ((\opt -> Core.TermMaybe (Maybes.map term opt)) (Core.caseStatementDefault x))}, - Core.Field { - Core.fieldName = (Core.Name "cases"), - Core.fieldTerm = ((\xs -> Core.TermList (Lists.map field xs)) (Core.caseStatementCases x))}]}) - -eitherType :: Core.EitherType -> Core.Term -eitherType x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.EitherType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "left"), - Core.fieldTerm = (type_ (Core.eitherTypeLeft x))}, - Core.Field { - Core.fieldName = (Core.Name "right"), - Core.fieldTerm = (type_ (Core.eitherTypeRight x))}]}) - -elimination :: Core.Elimination -> Core.Term -elimination x = - case x of - Core.EliminationRecord v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Elimination"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (projection v0)}}) - Core.EliminationUnion v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Elimination"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "union"), - Core.fieldTerm = (caseStatement v0)}}) - Core.EliminationWrap v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Elimination"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wrap"), - Core.fieldTerm = (name v0)}}) - -field :: Core.Field -> Core.Term -field x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (name (Core.fieldName x))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (term (Core.fieldTerm x))}]}) - -fieldType :: Core.FieldType -> Core.Term -fieldType x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.FieldType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (name (Core.fieldTypeName x))}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (type_ (Core.fieldTypeType x))}]}) - -floatType :: Core.FloatType -> Core.Term -floatType x = - case x of - Core.FloatTypeBigfloat -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.FloatType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "bigfloat"), - Core.fieldTerm = Core.TermUnit}}) - Core.FloatTypeFloat32 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.FloatType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "float32"), - Core.fieldTerm = Core.TermUnit}}) - Core.FloatTypeFloat64 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.FloatType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "float64"), - Core.fieldTerm = Core.TermUnit}}) - -floatValue :: Core.FloatValue -> Core.Term -floatValue x = - case x of - Core.FloatValueBigfloat v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.FloatValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "bigfloat"), - Core.fieldTerm = (Core.TermLiteral (Core.LiteralFloat (Core.FloatValueBigfloat v0)))}}) - Core.FloatValueFloat32 v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.FloatValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "float32"), - Core.fieldTerm = (Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat32 v0)))}}) - Core.FloatValueFloat64 v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.FloatValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "float64"), - Core.fieldTerm = (Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat64 v0)))}}) - -forallType :: Core.ForallType -> Core.Term -forallType x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.ForallType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "parameter"), - Core.fieldTerm = (name (Core.forallTypeParameter x))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (type_ (Core.forallTypeBody x))}]}) - -function :: Core.Function -> Core.Term -function x = - case x of - Core.FunctionElimination v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Function"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "elimination"), - Core.fieldTerm = (elimination v0)}}) - Core.FunctionLambda v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Function"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "lambda"), - Core.fieldTerm = (lambda v0)}}) - Core.FunctionPrimitive v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Function"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "primitive"), - Core.fieldTerm = (name v0)}}) - -functionType :: Core.FunctionType -> Core.Term -functionType x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.FunctionType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "domain"), - Core.fieldTerm = (type_ (Core.functionTypeDomain x))}, - Core.Field { - Core.fieldName = (Core.Name "codomain"), - Core.fieldTerm = (type_ (Core.functionTypeCodomain x))}]}) - -injection :: Core.Injection -> Core.Term -injection x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (name (Core.injectionTypeName x))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (field (Core.injectionField x))}]}) - -integerType :: Core.IntegerType -> Core.Term -integerType x = - case x of - Core.IntegerTypeBigint -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "bigint"), - Core.fieldTerm = Core.TermUnit}}) - Core.IntegerTypeInt8 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int8"), - Core.fieldTerm = Core.TermUnit}}) - Core.IntegerTypeInt16 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int16"), - Core.fieldTerm = Core.TermUnit}}) - Core.IntegerTypeInt32 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int32"), - Core.fieldTerm = Core.TermUnit}}) - Core.IntegerTypeInt64 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int64"), - Core.fieldTerm = Core.TermUnit}}) - Core.IntegerTypeUint8 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "uint8"), - Core.fieldTerm = Core.TermUnit}}) - Core.IntegerTypeUint16 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "uint16"), - Core.fieldTerm = Core.TermUnit}}) - Core.IntegerTypeUint32 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "uint32"), - Core.fieldTerm = Core.TermUnit}}) - Core.IntegerTypeUint64 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "uint64"), - Core.fieldTerm = Core.TermUnit}}) - -integerValue :: Core.IntegerValue -> Core.Term -integerValue x = - case x of - Core.IntegerValueBigint v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "bigint"), - Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueBigint v0)))}}) - Core.IntegerValueInt8 v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int8"), - Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt8 v0)))}}) - Core.IntegerValueInt16 v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int16"), - Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt16 v0)))}}) - Core.IntegerValueInt32 v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int32"), - Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 v0)))}}) - Core.IntegerValueInt64 v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int64"), - Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt64 v0)))}}) - Core.IntegerValueUint8 v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "uint8"), - Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueUint8 v0)))}}) - Core.IntegerValueUint16 v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "uint16"), - Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueUint16 v0)))}}) - Core.IntegerValueUint32 v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "uint32"), - Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueUint32 v0)))}}) - Core.IntegerValueUint64 v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "uint64"), - Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueUint64 v0)))}}) - -lambda :: Core.Lambda -> Core.Term -lambda x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Lambda"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "parameter"), - Core.fieldTerm = (name (Core.lambdaParameter x))}, - Core.Field { - Core.fieldName = (Core.Name "domain"), - Core.fieldTerm = ((\opt -> Core.TermMaybe (Maybes.map type_ opt)) (Core.lambdaDomain x))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (term (Core.lambdaBody x))}]}) - -let_ :: Core.Let -> Core.Term -let_ x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Let"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "bindings"), - Core.fieldTerm = ((\xs -> Core.TermList (Lists.map binding xs)) (Core.letBindings x))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (term (Core.letBody x))}]}) - -literal :: Core.Literal -> Core.Term -literal x = - case x of - Core.LiteralBinary v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "binary"), - Core.fieldTerm = (Core.TermLiteral (Core.LiteralBinary v0))}}) - Core.LiteralBoolean v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "boolean"), - Core.fieldTerm = (Core.TermLiteral (Core.LiteralBoolean v0))}}) - Core.LiteralFloat v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "float"), - Core.fieldTerm = (floatValue v0)}}) - Core.LiteralInteger v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (integerValue v0)}}) - Core.LiteralString v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermLiteral (Core.LiteralString v0))}}) - -literalType :: Core.LiteralType -> Core.Term -literalType x = - case x of - Core.LiteralTypeBinary -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.LiteralType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "binary"), - Core.fieldTerm = Core.TermUnit}}) - Core.LiteralTypeBoolean -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.LiteralType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "boolean"), - Core.fieldTerm = Core.TermUnit}}) - Core.LiteralTypeFloat v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.LiteralType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "float"), - Core.fieldTerm = (floatType v0)}}) - Core.LiteralTypeInteger v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.LiteralType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (integerType v0)}}) - Core.LiteralTypeString -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.LiteralType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = Core.TermUnit}}) - -mapType :: Core.MapType -> Core.Term -mapType x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.MapType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "keys"), - Core.fieldTerm = (type_ (Core.mapTypeKeys x))}, - Core.Field { - Core.fieldName = (Core.Name "values"), - Core.fieldTerm = (type_ (Core.mapTypeValues x))}]}) - -name :: Core.Name -> Core.Term -name x = - Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = ((\x -> Core.TermLiteral (Core.LiteralString x)) (Core.unName x))}) - -pairType :: Core.PairType -> Core.Term -pairType x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.PairType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "first"), - Core.fieldTerm = (type_ (Core.pairTypeFirst x))}, - Core.Field { - Core.fieldName = (Core.Name "second"), - Core.fieldTerm = (type_ (Core.pairTypeSecond x))}]}) - -projection :: Core.Projection -> Core.Term -projection x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Projection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (name (Core.projectionTypeName x))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (name (Core.projectionField x))}]}) - -record :: Core.Record -> Core.Term -record x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (name (Core.recordTypeName x))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = ((\xs -> Core.TermList (Lists.map field xs)) (Core.recordFields x))}]}) - -term :: Core.Term -> Core.Term -term x = - case x of - Core.TermAnnotated v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "annotated"), - Core.fieldTerm = (annotatedTerm v0)}}) - Core.TermApplication v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "application"), - Core.fieldTerm = (application v0)}}) - Core.TermEither v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "either"), - Core.fieldTerm = (Core.TermEither (Eithers.bimap term term v0))}}) - Core.TermFunction v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "function"), - Core.fieldTerm = (function v0)}}) - Core.TermLet v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "let"), - Core.fieldTerm = (let_ v0)}}) - Core.TermList v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermList (Lists.map term v0))}}) - Core.TermLiteral v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (literal v0)}}) - Core.TermMap v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "map"), - Core.fieldTerm = (Core.TermMap (Maps.bimap term term v0))}}) - Core.TermMaybe v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "maybe"), - Core.fieldTerm = (Core.TermMaybe (Maybes.map term v0))}}) - Core.TermPair v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "pair"), - Core.fieldTerm = (Core.TermPair (Pairs.bimap term term v0))}}) - Core.TermRecord v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (record v0)}}) - Core.TermSet v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "set"), - Core.fieldTerm = (Core.TermSet (Sets.map term v0))}}) - Core.TermTypeApplication v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "typeApplication"), - Core.fieldTerm = (typeApplicationTerm v0)}}) - Core.TermTypeLambda v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "typeLambda"), - Core.fieldTerm = (typeLambda v0)}}) - Core.TermUnion v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "union"), - Core.fieldTerm = (injection v0)}}) - Core.TermUnit -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}) - Core.TermVariable v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "variable"), - Core.fieldTerm = (name v0)}}) - Core.TermWrap v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wrap"), - Core.fieldTerm = (wrappedTerm v0)}}) - -type_ :: Core.Type -> Core.Term -type_ x = - case x of - Core.TypeAnnotated v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "annotated"), - Core.fieldTerm = (annotatedType v0)}}) - Core.TypeApplication v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "application"), - Core.fieldTerm = (applicationType v0)}}) - Core.TypeEither v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "either"), - Core.fieldTerm = (eitherType v0)}}) - Core.TypeForall v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "forall"), - Core.fieldTerm = (forallType v0)}}) - Core.TypeFunction v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "function"), - Core.fieldTerm = (functionType v0)}}) - Core.TypeList v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (type_ v0)}}) - Core.TypeLiteral v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (literalType v0)}}) - Core.TypeMap v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "map"), - Core.fieldTerm = (mapType v0)}}) - Core.TypeMaybe v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "maybe"), - Core.fieldTerm = (type_ v0)}}) - Core.TypePair v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "pair"), - Core.fieldTerm = (pairType v0)}}) - Core.TypeRecord v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermList (Lists.map fieldType v0))}}) - Core.TypeSet v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "set"), - Core.fieldTerm = (type_ v0)}}) - Core.TypeUnion v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "union"), - Core.fieldTerm = (Core.TermList (Lists.map fieldType v0))}}) - Core.TypeUnit -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}) - Core.TypeVariable v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "variable"), - Core.fieldTerm = (name v0)}}) - Core.TypeVoid -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "void"), - Core.fieldTerm = Core.TermUnit}}) - Core.TypeWrap v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wrap"), - Core.fieldTerm = (type_ v0)}}) - -typeApplicationTerm :: Core.TypeApplicationTerm -> Core.Term -typeApplicationTerm x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.TypeApplicationTerm"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (term (Core.typeApplicationTermBody x))}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (type_ (Core.typeApplicationTermType x))}]}) - -typeLambda :: Core.TypeLambda -> Core.Term -typeLambda x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.TypeLambda"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "parameter"), - Core.fieldTerm = (name (Core.typeLambdaParameter x))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (term (Core.typeLambdaBody x))}]}) - -typeScheme :: Core.TypeScheme -> Core.Term -typeScheme x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.TypeScheme"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "variables"), - Core.fieldTerm = ((\xs -> Core.TermList (Lists.map name xs)) (Core.typeSchemeVariables x))}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (type_ (Core.typeSchemeType x))}, - Core.Field { - Core.fieldName = (Core.Name "constraints"), - Core.fieldTerm = ((\opt -> Core.TermMaybe (Maybes.map (\m -> Core.TermMap (Maps.bimap name typeVariableMetadata m)) opt)) (Core.typeSchemeConstraints x))}]}) - -typeVariableMetadata :: Core.TypeVariableMetadata -> Core.Term -typeVariableMetadata x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.TypeVariableMetadata"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "classes"), - Core.fieldTerm = ((\s -> Core.TermSet (Sets.map name s)) (Core.typeVariableMetadataClasses x))}]}) - -wrappedTerm :: Core.WrappedTerm -> Core.Term -wrappedTerm x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (name (Core.wrappedTermTypeName x))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (term (Core.wrappedTermBody x))}]}) diff --git a/src/gen-main/haskell/Hydra/Encode/Error/Checking.hs b/src/gen-main/haskell/Hydra/Encode/Error/Checking.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Encode/Error/Checking.hs +++ /dev/null @@ -1,181 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Term encoders for hydra.error.checking - -module Hydra.Encode.Error.Checking where - -import qualified Hydra.Core as Core -import qualified Hydra.Encode.Core as Core_ -import qualified Hydra.Encode.Typing as Typing -import qualified Hydra.Encode.Variants as Variants -import qualified Hydra.Error.Checking as Checking -import qualified Hydra.Lib.Lists as Lists -import qualified Hydra.Lib.Sets as Sets -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -checkingError :: Checking.CheckingError -> Core.Term -checkingError x = - case x of - Checking.CheckingErrorIncorrectUnification v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "incorrectUnification"), - Core.fieldTerm = (incorrectUnificationError v0)}}) - Checking.CheckingErrorNotAForallType v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "notAForallType"), - Core.fieldTerm = (notAForallTypeError v0)}}) - Checking.CheckingErrorNotAFunctionType v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "notAFunctionType"), - Core.fieldTerm = (notAFunctionTypeError v0)}}) - Checking.CheckingErrorTypeArityMismatch v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "typeArityMismatch"), - Core.fieldTerm = (typeArityMismatchError v0)}}) - Checking.CheckingErrorTypeMismatch v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "typeMismatch"), - Core.fieldTerm = (typeMismatchError v0)}}) - Checking.CheckingErrorUnboundTypeVariables v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unboundTypeVariables"), - Core.fieldTerm = (unboundTypeVariablesError v0)}}) - Checking.CheckingErrorUnequalTypes v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unequalTypes"), - Core.fieldTerm = (unequalTypesError v0)}}) - Checking.CheckingErrorUnsupportedTermVariant v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unsupportedTermVariant"), - Core.fieldTerm = (unsupportedTermVariantError v0)}}) - Checking.CheckingErrorUntypedLambda v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "untypedLambda"), - Core.fieldTerm = (untypedLambdaError v0)}}) - Checking.CheckingErrorUntypedLetBinding v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "untypedLetBinding"), - Core.fieldTerm = (untypedLetBindingError v0)}}) - -incorrectUnificationError :: Checking.IncorrectUnificationError -> Core.Term -incorrectUnificationError x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.IncorrectUnificationError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "substitution"), - Core.fieldTerm = (Typing.typeSubst (Checking.incorrectUnificationErrorSubstitution x))}]}) - -notAForallTypeError :: Checking.NotAForallTypeError -> Core.Term -notAForallTypeError x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.NotAForallTypeError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core_.type_ (Checking.notAForallTypeErrorType x))}, - Core.Field { - Core.fieldName = (Core.Name "typeArguments"), - Core.fieldTerm = ((\xs -> Core.TermList (Lists.map Core_.type_ xs)) (Checking.notAForallTypeErrorTypeArguments x))}]}) - -notAFunctionTypeError :: Checking.NotAFunctionTypeError -> Core.Term -notAFunctionTypeError x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.NotAFunctionTypeError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core_.type_ (Checking.notAFunctionTypeErrorType x))}]}) - -typeArityMismatchError :: Checking.TypeArityMismatchError -> Core.Term -typeArityMismatchError x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.TypeArityMismatchError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core_.type_ (Checking.typeArityMismatchErrorType x))}, - Core.Field { - Core.fieldName = (Core.Name "expectedArity"), - Core.fieldTerm = ((\x -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x))) (Checking.typeArityMismatchErrorExpectedArity x))}, - Core.Field { - Core.fieldName = (Core.Name "actualArity"), - Core.fieldTerm = ((\x -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x))) (Checking.typeArityMismatchErrorActualArity x))}, - Core.Field { - Core.fieldName = (Core.Name "typeArguments"), - Core.fieldTerm = ((\xs -> Core.TermList (Lists.map Core_.type_ xs)) (Checking.typeArityMismatchErrorTypeArguments x))}]}) - -typeMismatchError :: Checking.TypeMismatchError -> Core.Term -typeMismatchError x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.TypeMismatchError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "expectedType"), - Core.fieldTerm = (Core_.type_ (Checking.typeMismatchErrorExpectedType x))}, - Core.Field { - Core.fieldName = (Core.Name "actualType"), - Core.fieldTerm = (Core_.type_ (Checking.typeMismatchErrorActualType x))}]}) - -unboundTypeVariablesError :: Checking.UnboundTypeVariablesError -> Core.Term -unboundTypeVariablesError x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.UnboundTypeVariablesError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "variables"), - Core.fieldTerm = ((\s -> Core.TermSet (Sets.map Core_.name s)) (Checking.unboundTypeVariablesErrorVariables x))}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core_.type_ (Checking.unboundTypeVariablesErrorType x))}]}) - -unequalTypesError :: Checking.UnequalTypesError -> Core.Term -unequalTypesError x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.UnequalTypesError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "types"), - Core.fieldTerm = ((\xs -> Core.TermList (Lists.map Core_.type_ xs)) (Checking.unequalTypesErrorTypes x))}, - Core.Field { - Core.fieldName = (Core.Name "description"), - Core.fieldTerm = ((\x -> Core.TermLiteral (Core.LiteralString x)) (Checking.unequalTypesErrorDescription x))}]}) - -unsupportedTermVariantError :: Checking.UnsupportedTermVariantError -> Core.Term -unsupportedTermVariantError x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.UnsupportedTermVariantError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "termVariant"), - Core.fieldTerm = (Variants.termVariant (Checking.unsupportedTermVariantErrorTermVariant x))}]}) - -untypedLambdaError :: t0 -> Core.Term -untypedLambdaError x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.UntypedLambdaError"), - Core.recordFields = []}) - -untypedLetBindingError :: Checking.UntypedLetBindingError -> Core.Term -untypedLetBindingError x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.UntypedLetBindingError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "binding"), - Core.fieldTerm = (Core_.binding (Checking.untypedLetBindingErrorBinding x))}]}) diff --git a/src/gen-main/haskell/Hydra/Encode/Error/Core.hs b/src/gen-main/haskell/Hydra/Encode/Error/Core.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Encode/Error/Core.hs +++ /dev/null @@ -1,643 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Term encoders for hydra.error.core - -module Hydra.Encode.Error.Core where - -import qualified Hydra.Core as Core -import qualified Hydra.Encode.Core as Core_ -import qualified Hydra.Encode.Paths as Paths -import qualified Hydra.Encode.Variants as Variants -import qualified Hydra.Error.Core as Core__ -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -constantConditionError :: Core__.ConstantConditionError -> Core.Term -constantConditionError x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.ConstantConditionError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Paths.subtermPath (Core__.constantConditionErrorLocation x))}, - Core.Field { - Core.fieldName = (Core.Name "value"), - Core.fieldTerm = ((\x -> Core.TermLiteral (Core.LiteralBoolean x)) (Core__.constantConditionErrorValue x))}]}) - -duplicateBindingError :: Core__.DuplicateBindingError -> Core.Term -duplicateBindingError x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.DuplicateBindingError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Paths.subtermPath (Core__.duplicateBindingErrorLocation x))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core_.name (Core__.duplicateBindingErrorName x))}]}) - -duplicateFieldError :: Core__.DuplicateFieldError -> Core.Term -duplicateFieldError x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.DuplicateFieldError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Paths.subtermPath (Core__.duplicateFieldErrorLocation x))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core_.name (Core__.duplicateFieldErrorName x))}]}) - -duplicateRecordTypeFieldNamesError :: Core__.DuplicateRecordTypeFieldNamesError -> Core.Term -duplicateRecordTypeFieldNamesError x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.DuplicateRecordTypeFieldNamesError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Paths.subtermPath (Core__.duplicateRecordTypeFieldNamesErrorLocation x))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core_.name (Core__.duplicateRecordTypeFieldNamesErrorName x))}]}) - -duplicateUnionTypeFieldNamesError :: Core__.DuplicateUnionTypeFieldNamesError -> Core.Term -duplicateUnionTypeFieldNamesError x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.DuplicateUnionTypeFieldNamesError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Paths.subtermPath (Core__.duplicateUnionTypeFieldNamesErrorLocation x))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core_.name (Core__.duplicateUnionTypeFieldNamesErrorName x))}]}) - -emptyCaseStatementError :: Core__.EmptyCaseStatementError -> Core.Term -emptyCaseStatementError x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.EmptyCaseStatementError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Paths.subtermPath (Core__.emptyCaseStatementErrorLocation x))}, - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core_.name (Core__.emptyCaseStatementErrorTypeName x))}]}) - -emptyLetBindingsError :: Core__.EmptyLetBindingsError -> Core.Term -emptyLetBindingsError x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.EmptyLetBindingsError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Paths.subtermPath (Core__.emptyLetBindingsErrorLocation x))}]}) - -emptyRecordTypeError :: Core__.EmptyRecordTypeError -> Core.Term -emptyRecordTypeError x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.EmptyRecordTypeError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Paths.subtermPath (Core__.emptyRecordTypeErrorLocation x))}]}) - -emptyTermAnnotationError :: Core__.EmptyTermAnnotationError -> Core.Term -emptyTermAnnotationError x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.EmptyTermAnnotationError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Paths.subtermPath (Core__.emptyTermAnnotationErrorLocation x))}]}) - -emptyTypeAnnotationError :: Core__.EmptyTypeAnnotationError -> Core.Term -emptyTypeAnnotationError x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.EmptyTypeAnnotationError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Paths.subtermPath (Core__.emptyTypeAnnotationErrorLocation x))}]}) - -emptyTypeNameInTermError :: Core__.EmptyTypeNameInTermError -> Core.Term -emptyTypeNameInTermError x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.EmptyTypeNameInTermError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Paths.subtermPath (Core__.emptyTypeNameInTermErrorLocation x))}]}) - -emptyUnionTypeError :: Core__.EmptyUnionTypeError -> Core.Term -emptyUnionTypeError x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.EmptyUnionTypeError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Paths.subtermPath (Core__.emptyUnionTypeErrorLocation x))}]}) - -invalidForallParameterNameError :: Core__.InvalidForallParameterNameError -> Core.Term -invalidForallParameterNameError x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.InvalidForallParameterNameError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Paths.subtermPath (Core__.invalidForallParameterNameErrorLocation x))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core_.name (Core__.invalidForallParameterNameErrorName x))}]}) - -invalidLambdaParameterNameError :: Core__.InvalidLambdaParameterNameError -> Core.Term -invalidLambdaParameterNameError x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.InvalidLambdaParameterNameError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Paths.subtermPath (Core__.invalidLambdaParameterNameErrorLocation x))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core_.name (Core__.invalidLambdaParameterNameErrorName x))}]}) - -invalidLetBindingNameError :: Core__.InvalidLetBindingNameError -> Core.Term -invalidLetBindingNameError x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.InvalidLetBindingNameError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Paths.subtermPath (Core__.invalidLetBindingNameErrorLocation x))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core_.name (Core__.invalidLetBindingNameErrorName x))}]}) - -invalidTermError :: Core__.InvalidTermError -> Core.Term -invalidTermError x = - case x of - Core__.InvalidTermErrorConstantCondition v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "constantCondition"), - Core.fieldTerm = (constantConditionError v0)}}) - Core__.InvalidTermErrorDuplicateBinding v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "duplicateBinding"), - Core.fieldTerm = (duplicateBindingError v0)}}) - Core__.InvalidTermErrorDuplicateField v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "duplicateField"), - Core.fieldTerm = (duplicateFieldError v0)}}) - Core__.InvalidTermErrorEmptyCaseStatement v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "emptyCaseStatement"), - Core.fieldTerm = (emptyCaseStatementError v0)}}) - Core__.InvalidTermErrorEmptyLetBindings v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "emptyLetBindings"), - Core.fieldTerm = (emptyLetBindingsError v0)}}) - Core__.InvalidTermErrorEmptyTermAnnotation v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "emptyTermAnnotation"), - Core.fieldTerm = (emptyTermAnnotationError v0)}}) - Core__.InvalidTermErrorEmptyTypeNameInTerm v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "emptyTypeNameInTerm"), - Core.fieldTerm = (emptyTypeNameInTermError v0)}}) - Core__.InvalidTermErrorInvalidLambdaParameterName v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "invalidLambdaParameterName"), - Core.fieldTerm = (invalidLambdaParameterNameError v0)}}) - Core__.InvalidTermErrorInvalidLetBindingName v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "invalidLetBindingName"), - Core.fieldTerm = (invalidLetBindingNameError v0)}}) - Core__.InvalidTermErrorInvalidTypeLambdaParameterName v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "invalidTypeLambdaParameterName"), - Core.fieldTerm = (invalidTypeLambdaParameterNameError v0)}}) - Core__.InvalidTermErrorNestedTermAnnotation v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "nestedTermAnnotation"), - Core.fieldTerm = (nestedTermAnnotationError v0)}}) - Core__.InvalidTermErrorRedundantWrapUnwrap v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "redundantWrapUnwrap"), - Core.fieldTerm = (redundantWrapUnwrapError v0)}}) - Core__.InvalidTermErrorSelfApplication v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "selfApplication"), - Core.fieldTerm = (selfApplicationError v0)}}) - Core__.InvalidTermErrorTermVariableShadowing v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "termVariableShadowing"), - Core.fieldTerm = (termVariableShadowingError v0)}}) - Core__.InvalidTermErrorTypeVariableShadowingInTypeLambda v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "typeVariableShadowingInTypeLambda"), - Core.fieldTerm = (typeVariableShadowingInTypeLambdaError v0)}}) - Core__.InvalidTermErrorUndefinedTermVariable v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "undefinedTermVariable"), - Core.fieldTerm = (undefinedTermVariableError v0)}}) - Core__.InvalidTermErrorUndefinedTypeVariableInBindingType v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "undefinedTypeVariableInBindingType"), - Core.fieldTerm = (undefinedTypeVariableInBindingTypeError v0)}}) - Core__.InvalidTermErrorUndefinedTypeVariableInLambdaDomain v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "undefinedTypeVariableInLambdaDomain"), - Core.fieldTerm = (undefinedTypeVariableInLambdaDomainError v0)}}) - Core__.InvalidTermErrorUndefinedTypeVariableInTypeApplication v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "undefinedTypeVariableInTypeApplication"), - Core.fieldTerm = (undefinedTypeVariableInTypeApplicationError v0)}}) - Core__.InvalidTermErrorUnknownPrimitiveName v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unknownPrimitiveName"), - Core.fieldTerm = (unknownPrimitiveNameError v0)}}) - Core__.InvalidTermErrorUnnecessaryIdentityApplication v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unnecessaryIdentityApplication"), - Core.fieldTerm = (unnecessaryIdentityApplicationError v0)}}) - Core__.InvalidTermErrorUntypedTermVariable v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "untypedTermVariable"), - Core.fieldTerm = (untypedTermVariableError v0)}}) - -invalidTypeError :: Core__.InvalidTypeError -> Core.Term -invalidTypeError x = - case x of - Core__.InvalidTypeErrorDuplicateRecordTypeFieldNames v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "duplicateRecordTypeFieldNames"), - Core.fieldTerm = (duplicateRecordTypeFieldNamesError v0)}}) - Core__.InvalidTypeErrorDuplicateUnionTypeFieldNames v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "duplicateUnionTypeFieldNames"), - Core.fieldTerm = (duplicateUnionTypeFieldNamesError v0)}}) - Core__.InvalidTypeErrorEmptyRecordType v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "emptyRecordType"), - Core.fieldTerm = (emptyRecordTypeError v0)}}) - Core__.InvalidTypeErrorEmptyTypeAnnotation v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "emptyTypeAnnotation"), - Core.fieldTerm = (emptyTypeAnnotationError v0)}}) - Core__.InvalidTypeErrorEmptyUnionType v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "emptyUnionType"), - Core.fieldTerm = (emptyUnionTypeError v0)}}) - Core__.InvalidTypeErrorInvalidForallParameterName v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "invalidForallParameterName"), - Core.fieldTerm = (invalidForallParameterNameError v0)}}) - Core__.InvalidTypeErrorInvalidTypeSchemeVariableName v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "invalidTypeSchemeVariableName"), - Core.fieldTerm = (invalidTypeSchemeVariableNameError v0)}}) - Core__.InvalidTypeErrorNestedTypeAnnotation v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "nestedTypeAnnotation"), - Core.fieldTerm = (nestedTypeAnnotationError v0)}}) - Core__.InvalidTypeErrorNonComparableMapKeyType v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "nonComparableMapKeyType"), - Core.fieldTerm = (nonComparableMapKeyTypeError v0)}}) - Core__.InvalidTypeErrorNonComparableSetElementType v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "nonComparableSetElementType"), - Core.fieldTerm = (nonComparableSetElementTypeError v0)}}) - Core__.InvalidTypeErrorSingleVariantUnion v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "singleVariantUnion"), - Core.fieldTerm = (singleVariantUnionError v0)}}) - Core__.InvalidTypeErrorTypeVariableShadowingInForall v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "typeVariableShadowingInForall"), - Core.fieldTerm = (typeVariableShadowingInForallError v0)}}) - Core__.InvalidTypeErrorUndefinedTypeVariable v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "undefinedTypeVariable"), - Core.fieldTerm = (undefinedTypeVariableError v0)}}) - Core__.InvalidTypeErrorVoidInNonBottomPosition v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "voidInNonBottomPosition"), - Core.fieldTerm = (voidInNonBottomPositionError v0)}}) - -invalidTypeLambdaParameterNameError :: Core__.InvalidTypeLambdaParameterNameError -> Core.Term -invalidTypeLambdaParameterNameError x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.InvalidTypeLambdaParameterNameError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Paths.subtermPath (Core__.invalidTypeLambdaParameterNameErrorLocation x))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core_.name (Core__.invalidTypeLambdaParameterNameErrorName x))}]}) - -invalidTypeSchemeVariableNameError :: Core__.InvalidTypeSchemeVariableNameError -> Core.Term -invalidTypeSchemeVariableNameError x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.InvalidTypeSchemeVariableNameError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Paths.subtermPath (Core__.invalidTypeSchemeVariableNameErrorLocation x))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core_.name (Core__.invalidTypeSchemeVariableNameErrorName x))}]}) - -nestedTermAnnotationError :: Core__.NestedTermAnnotationError -> Core.Term -nestedTermAnnotationError x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.NestedTermAnnotationError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Paths.subtermPath (Core__.nestedTermAnnotationErrorLocation x))}]}) - -nestedTypeAnnotationError :: Core__.NestedTypeAnnotationError -> Core.Term -nestedTypeAnnotationError x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.NestedTypeAnnotationError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Paths.subtermPath (Core__.nestedTypeAnnotationErrorLocation x))}]}) - -nonComparableMapKeyTypeError :: Core__.NonComparableMapKeyTypeError -> Core.Term -nonComparableMapKeyTypeError x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.NonComparableMapKeyTypeError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Paths.subtermPath (Core__.nonComparableMapKeyTypeErrorLocation x))}, - Core.Field { - Core.fieldName = (Core.Name "keyType"), - Core.fieldTerm = (Core_.type_ (Core__.nonComparableMapKeyTypeErrorKeyType x))}]}) - -nonComparableSetElementTypeError :: Core__.NonComparableSetElementTypeError -> Core.Term -nonComparableSetElementTypeError x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.NonComparableSetElementTypeError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Paths.subtermPath (Core__.nonComparableSetElementTypeErrorLocation x))}, - Core.Field { - Core.fieldName = (Core.Name "elementType"), - Core.fieldTerm = (Core_.type_ (Core__.nonComparableSetElementTypeErrorElementType x))}]}) - -redundantWrapUnwrapError :: Core__.RedundantWrapUnwrapError -> Core.Term -redundantWrapUnwrapError x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.RedundantWrapUnwrapError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Paths.subtermPath (Core__.redundantWrapUnwrapErrorLocation x))}, - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core_.name (Core__.redundantWrapUnwrapErrorTypeName x))}]}) - -selfApplicationError :: Core__.SelfApplicationError -> Core.Term -selfApplicationError x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.SelfApplicationError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Paths.subtermPath (Core__.selfApplicationErrorLocation x))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core_.name (Core__.selfApplicationErrorName x))}]}) - -singleVariantUnionError :: Core__.SingleVariantUnionError -> Core.Term -singleVariantUnionError x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.SingleVariantUnionError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Paths.subtermPath (Core__.singleVariantUnionErrorLocation x))}, - Core.Field { - Core.fieldName = (Core.Name "fieldName"), - Core.fieldTerm = (Core_.name (Core__.singleVariantUnionErrorFieldName x))}]}) - -termVariableShadowingError :: Core__.TermVariableShadowingError -> Core.Term -termVariableShadowingError x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.TermVariableShadowingError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Paths.subtermPath (Core__.termVariableShadowingErrorLocation x))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core_.name (Core__.termVariableShadowingErrorName x))}]}) - -typeVariableShadowingInForallError :: Core__.TypeVariableShadowingInForallError -> Core.Term -typeVariableShadowingInForallError x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.TypeVariableShadowingInForallError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Paths.subtermPath (Core__.typeVariableShadowingInForallErrorLocation x))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core_.name (Core__.typeVariableShadowingInForallErrorName x))}]}) - -typeVariableShadowingInTypeLambdaError :: Core__.TypeVariableShadowingInTypeLambdaError -> Core.Term -typeVariableShadowingInTypeLambdaError x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.TypeVariableShadowingInTypeLambdaError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Paths.subtermPath (Core__.typeVariableShadowingInTypeLambdaErrorLocation x))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core_.name (Core__.typeVariableShadowingInTypeLambdaErrorName x))}]}) - -undefinedFieldError :: Core__.UndefinedFieldError -> Core.Term -undefinedFieldError x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedFieldError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "fieldName"), - Core.fieldTerm = (Core_.name (Core__.undefinedFieldErrorFieldName x))}, - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core_.name (Core__.undefinedFieldErrorTypeName x))}]}) - -undefinedTermVariableError :: Core__.UndefinedTermVariableError -> Core.Term -undefinedTermVariableError x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedTermVariableError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Paths.subtermPath (Core__.undefinedTermVariableErrorLocation x))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core_.name (Core__.undefinedTermVariableErrorName x))}]}) - -undefinedTypeVariableError :: Core__.UndefinedTypeVariableError -> Core.Term -undefinedTypeVariableError x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Paths.subtermPath (Core__.undefinedTypeVariableErrorLocation x))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core_.name (Core__.undefinedTypeVariableErrorName x))}]}) - -undefinedTypeVariableInBindingTypeError :: Core__.UndefinedTypeVariableInBindingTypeError -> Core.Term -undefinedTypeVariableInBindingTypeError x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInBindingTypeError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Paths.subtermPath (Core__.undefinedTypeVariableInBindingTypeErrorLocation x))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core_.name (Core__.undefinedTypeVariableInBindingTypeErrorName x))}]}) - -undefinedTypeVariableInLambdaDomainError :: Core__.UndefinedTypeVariableInLambdaDomainError -> Core.Term -undefinedTypeVariableInLambdaDomainError x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInLambdaDomainError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Paths.subtermPath (Core__.undefinedTypeVariableInLambdaDomainErrorLocation x))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core_.name (Core__.undefinedTypeVariableInLambdaDomainErrorName x))}]}) - -undefinedTypeVariableInTypeApplicationError :: Core__.UndefinedTypeVariableInTypeApplicationError -> Core.Term -undefinedTypeVariableInTypeApplicationError x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInTypeApplicationError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Paths.subtermPath (Core__.undefinedTypeVariableInTypeApplicationErrorLocation x))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core_.name (Core__.undefinedTypeVariableInTypeApplicationErrorName x))}]}) - -unexpectedTermVariantError :: Core__.UnexpectedTermVariantError -> Core.Term -unexpectedTermVariantError x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UnexpectedTermVariantError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "expectedVariant"), - Core.fieldTerm = (Variants.termVariant (Core__.unexpectedTermVariantErrorExpectedVariant x))}, - Core.Field { - Core.fieldName = (Core.Name "actualTerm"), - Core.fieldTerm = (Core_.term (Core__.unexpectedTermVariantErrorActualTerm x))}]}) - -unexpectedTypeVariantError :: Core__.UnexpectedTypeVariantError -> Core.Term -unexpectedTypeVariantError x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UnexpectedTypeVariantError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "expectedVariant"), - Core.fieldTerm = (Variants.typeVariant (Core__.unexpectedTypeVariantErrorExpectedVariant x))}, - Core.Field { - Core.fieldName = (Core.Name "actualType"), - Core.fieldTerm = (Core_.type_ (Core__.unexpectedTypeVariantErrorActualType x))}]}) - -unknownPrimitiveNameError :: Core__.UnknownPrimitiveNameError -> Core.Term -unknownPrimitiveNameError x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UnknownPrimitiveNameError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Paths.subtermPath (Core__.unknownPrimitiveNameErrorLocation x))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core_.name (Core__.unknownPrimitiveNameErrorName x))}]}) - -unnecessaryIdentityApplicationError :: Core__.UnnecessaryIdentityApplicationError -> Core.Term -unnecessaryIdentityApplicationError x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UnnecessaryIdentityApplicationError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Paths.subtermPath (Core__.unnecessaryIdentityApplicationErrorLocation x))}]}) - -untypedTermVariableError :: Core__.UntypedTermVariableError -> Core.Term -untypedTermVariableError x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UntypedTermVariableError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Paths.subtermPath (Core__.untypedTermVariableErrorLocation x))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core_.name (Core__.untypedTermVariableErrorName x))}]}) - -voidInNonBottomPositionError :: Core__.VoidInNonBottomPositionError -> Core.Term -voidInNonBottomPositionError x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.VoidInNonBottomPositionError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Paths.subtermPath (Core__.voidInNonBottomPositionErrorLocation x))}]}) diff --git a/src/gen-main/haskell/Hydra/Encode/Errors.hs b/src/gen-main/haskell/Hydra/Encode/Errors.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Encode/Errors.hs +++ /dev/null @@ -1,103 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Term encoders for hydra.errors - -module Hydra.Encode.Errors where - -import qualified Hydra.Core as Core -import qualified Hydra.Encode.Core as Core_ -import qualified Hydra.Encode.Error.Checking as Checking -import qualified Hydra.Encode.Error.Core as Core__ -import qualified Hydra.Errors as Errors -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -decodingError :: Errors.DecodingError -> Core.Term -decodingError x = - Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = ((\x -> Core.TermLiteral (Core.LiteralString x)) (Errors.unDecodingError x))}) - -error :: Errors.Error -> Core.Term -error x = - case x of - Errors.ErrorChecking v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.Error"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "checking"), - Core.fieldTerm = (Checking.checkingError v0)}}) - Errors.ErrorDecoding v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.Error"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "decoding"), - Core.fieldTerm = (decodingError v0)}}) - Errors.ErrorDuplicateBinding v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.Error"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "duplicateBinding"), - Core.fieldTerm = (Core__.duplicateBindingError v0)}}) - Errors.ErrorDuplicateField v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.Error"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "duplicateField"), - Core.fieldTerm = (Core__.duplicateFieldError v0)}}) - Errors.ErrorOther v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.Error"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "other"), - Core.fieldTerm = (otherError v0)}}) - Errors.ErrorUndefinedField v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.Error"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "undefinedField"), - Core.fieldTerm = (Core__.undefinedFieldError v0)}}) - Errors.ErrorUndefinedTermVariable v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.Error"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "undefinedTermVariable"), - Core.fieldTerm = (Core__.undefinedTermVariableError v0)}}) - Errors.ErrorUntypedTermVariable v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.Error"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "untypedTermVariable"), - Core.fieldTerm = (Core__.untypedTermVariableError v0)}}) - Errors.ErrorUnexpectedTermVariant v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.Error"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unexpectedTermVariant"), - Core.fieldTerm = (Core__.unexpectedTermVariantError v0)}}) - Errors.ErrorUnexpectedTypeVariant v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.Error"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unexpectedTypeVariant"), - Core.fieldTerm = (Core__.unexpectedTypeVariantError v0)}}) - Errors.ErrorUnification v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.Error"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unification"), - Core.fieldTerm = (unificationError v0)}}) - -otherError :: Errors.OtherError -> Core.Term -otherError x = - Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.OtherError"), - Core.wrappedTermBody = ((\x -> Core.TermLiteral (Core.LiteralString x)) (Errors.unOtherError x))}) - -unificationError :: Errors.UnificationError -> Core.Term -unificationError x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.errors.UnificationError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "leftType"), - Core.fieldTerm = (Core_.type_ (Errors.unificationErrorLeftType x))}, - Core.Field { - Core.fieldName = (Core.Name "rightType"), - Core.fieldTerm = (Core_.type_ (Errors.unificationErrorRightType x))}, - Core.Field { - Core.fieldName = (Core.Name "message"), - Core.fieldTerm = ((\x -> Core.TermLiteral (Core.LiteralString x)) (Errors.unificationErrorMessage x))}]}) diff --git a/src/gen-main/haskell/Hydra/Encode/Json.hs b/src/gen-main/haskell/Hydra/Encode/Json.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Encode/Json.hs +++ /dev/null @@ -1,49 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Term encoders for hydra.json - -module Hydra.Encode.Json where - -import qualified Hydra.Core as Core -import qualified Hydra.Json.Model as Model -import qualified Hydra.Lib.Lists as Lists -import qualified Hydra.Lib.Maps as Maps -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -value :: (Model.Value -> Core.Term) -value x = case x of - Model.ValueArray v1 -> (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.json.model.Value"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "array"), - Core.fieldTerm = (Core.TermList (Lists.map value v1))}})) - Model.ValueBoolean v1 -> (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.json.model.Value"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "boolean"), - Core.fieldTerm = (Core.TermLiteral (Core.LiteralBoolean v1))}})) - Model.ValueNull -> (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.json.model.Value"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "null"), - Core.fieldTerm = Core.TermUnit}})) - Model.ValueNumber v1 -> (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.json.model.Value"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "number"), - Core.fieldTerm = (Core.TermLiteral (Core.LiteralFloat (Core.FloatValueBigfloat v1)))}})) - Model.ValueObject v1 -> (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.json.model.Value"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "object"), - Core.fieldTerm = (Core.TermMap (Maps.bimap (\x -> Core.TermLiteral (Core.LiteralString x)) value v1))}})) - Model.ValueString v1 -> (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.json.model.Value"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermLiteral (Core.LiteralString v1))}})) diff --git a/src/gen-main/haskell/Hydra/Encode/Json/Model.hs b/src/gen-main/haskell/Hydra/Encode/Json/Model.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Encode/Json/Model.hs +++ /dev/null @@ -1,50 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Term encoders for hydra.json.model - -module Hydra.Encode.Json.Model where - -import qualified Hydra.Core as Core -import qualified Hydra.Json.Model as Model -import qualified Hydra.Lib.Lists as Lists -import qualified Hydra.Lib.Maps as Maps -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -value :: Model.Value -> Core.Term -value x = - case x of - Model.ValueArray v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.json.model.Value"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "array"), - Core.fieldTerm = (Core.TermList (Lists.map value v0))}}) - Model.ValueBoolean v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.json.model.Value"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "boolean"), - Core.fieldTerm = (Core.TermLiteral (Core.LiteralBoolean v0))}}) - Model.ValueNull -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.json.model.Value"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "null"), - Core.fieldTerm = Core.TermUnit}}) - Model.ValueNumber v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.json.model.Value"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "number"), - Core.fieldTerm = (Core.TermLiteral (Core.LiteralFloat (Core.FloatValueBigfloat v0)))}}) - Model.ValueObject v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.json.model.Value"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "object"), - Core.fieldTerm = (Core.TermMap (Maps.bimap (\x -> Core.TermLiteral (Core.LiteralString x)) value v0))}}) - Model.ValueString v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.json.model.Value"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermLiteral (Core.LiteralString v0))}}) diff --git a/src/gen-main/haskell/Hydra/Encode/Module.hs b/src/gen-main/haskell/Hydra/Encode/Module.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Encode/Module.hs +++ /dev/null @@ -1,117 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Term encoders for hydra.module - -module Hydra.Encode.Module where - -import qualified Hydra.Core as Core -import qualified Hydra.Encode.Core as Core_ -import qualified Hydra.Lib.Lists as Lists -import qualified Hydra.Lib.Maps as Maps -import qualified Hydra.Lib.Maybes as Maybes -import qualified Hydra.Lib.Pairs as Pairs -import qualified Hydra.Module as Module -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -definition :: Module.Definition -> Core.Term -definition x = - case x of - Module.DefinitionTerm v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.module.Definition"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (termDefinition v0)}}) - Module.DefinitionType v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.module.Definition"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (typeDefinition v0)}}) - -fileExtension :: Module.FileExtension -> Core.Term -fileExtension x = - Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.module.FileExtension"), - Core.wrappedTermBody = ((\x -> Core.TermLiteral (Core.LiteralString x)) (Module.unFileExtension x))}) - -module_ :: Module.Module -> Core.Term -module_ x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.module.Module"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "namespace"), - Core.fieldTerm = (namespace (Module.moduleNamespace x))}, - Core.Field { - Core.fieldName = (Core.Name "definitions"), - Core.fieldTerm = ((\xs -> Core.TermList (Lists.map definition xs)) (Module.moduleDefinitions x))}, - Core.Field { - Core.fieldName = (Core.Name "termDependencies"), - Core.fieldTerm = ((\xs -> Core.TermList (Lists.map namespace xs)) (Module.moduleTermDependencies x))}, - Core.Field { - Core.fieldName = (Core.Name "typeDependencies"), - Core.fieldTerm = ((\xs -> Core.TermList (Lists.map namespace xs)) (Module.moduleTypeDependencies x))}, - Core.Field { - Core.fieldName = (Core.Name "description"), - Core.fieldTerm = ((\opt -> Core.TermMaybe (Maybes.map (\x -> Core.TermLiteral (Core.LiteralString x)) opt)) (Module.moduleDescription x))}]}) - -namespace :: Module.Namespace -> Core.Term -namespace x = - Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.module.Namespace"), - Core.wrappedTermBody = ((\x -> Core.TermLiteral (Core.LiteralString x)) (Module.unNamespace x))}) - -namespaces :: (t0 -> Core.Term) -> Module.Namespaces t0 -> Core.Term -namespaces n x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.module.Namespaces"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "focus"), - Core.fieldTerm = ((\p -> Core.TermPair (Pairs.bimap namespace n p)) (Module.namespacesFocus x))}, - Core.Field { - Core.fieldName = (Core.Name "mapping"), - Core.fieldTerm = ((\m -> Core.TermMap (Maps.bimap namespace n m)) (Module.namespacesMapping x))}]}) - -qualifiedName :: Module.QualifiedName -> Core.Term -qualifiedName x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.module.QualifiedName"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "namespace"), - Core.fieldTerm = ((\opt -> Core.TermMaybe (Maybes.map namespace opt)) (Module.qualifiedNameNamespace x))}, - Core.Field { - Core.fieldName = (Core.Name "local"), - Core.fieldTerm = ((\x -> Core.TermLiteral (Core.LiteralString x)) (Module.qualifiedNameLocal x))}]}) - -termDefinition :: Module.TermDefinition -> Core.Term -termDefinition x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.module.TermDefinition"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core_.name (Module.termDefinitionName x))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core_.term (Module.termDefinitionTerm x))}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = ((\opt -> Core.TermMaybe (Maybes.map Core_.typeScheme opt)) (Module.termDefinitionType x))}]}) - -typeDefinition :: Module.TypeDefinition -> Core.Term -typeDefinition x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.module.TypeDefinition"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core_.name (Module.typeDefinitionName x))}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core_.type_ (Module.typeDefinitionType x))}]}) diff --git a/src/gen-main/haskell/Hydra/Encode/Parsing.hs b/src/gen-main/haskell/Hydra/Encode/Parsing.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Encode/Parsing.hs +++ /dev/null @@ -1,52 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Term encoders for hydra.parsing - -module Hydra.Encode.Parsing where - -import qualified Hydra.Core as Core -import qualified Hydra.Parsing as Parsing -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -parseError :: Parsing.ParseError -> Core.Term -parseError x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.parsing.ParseError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "message"), - Core.fieldTerm = ((\x -> Core.TermLiteral (Core.LiteralString x)) (Parsing.parseErrorMessage x))}, - Core.Field { - Core.fieldName = (Core.Name "remainder"), - Core.fieldTerm = ((\x -> Core.TermLiteral (Core.LiteralString x)) (Parsing.parseErrorRemainder x))}]}) - -parseResult :: (t0 -> Core.Term) -> Parsing.ParseResult t0 -> Core.Term -parseResult a x = - case x of - Parsing.ParseResultSuccess v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.parsing.ParseResult"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "success"), - Core.fieldTerm = (parseSuccess a v0)}}) - Parsing.ParseResultFailure v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.parsing.ParseResult"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "failure"), - Core.fieldTerm = (parseError v0)}}) - -parseSuccess :: (t0 -> Core.Term) -> Parsing.ParseSuccess t0 -> Core.Term -parseSuccess a x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.parsing.ParseSuccess"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "value"), - Core.fieldTerm = (a (Parsing.parseSuccessValue x))}, - Core.Field { - Core.fieldName = (Core.Name "remainder"), - Core.fieldTerm = ((\x -> Core.TermLiteral (Core.LiteralString x)) (Parsing.parseSuccessRemainder x))}]}) diff --git a/src/gen-main/haskell/Hydra/Encode/Paths.hs b/src/gen-main/haskell/Hydra/Encode/Paths.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Encode/Paths.hs +++ /dev/null @@ -1,310 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Term encoders for hydra.paths - -module Hydra.Encode.Paths where - -import qualified Hydra.Core as Core -import qualified Hydra.Encode.Core as Core_ -import qualified Hydra.Lib.Lists as Lists -import qualified Hydra.Paths as Paths -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -subtermEdge :: Paths.SubtermEdge -> Core.Term -subtermEdge x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.paths.SubtermEdge"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "source"), - Core.fieldTerm = (subtermNode (Paths.subtermEdgeSource x))}, - Core.Field { - Core.fieldName = (Core.Name "path"), - Core.fieldTerm = (subtermPath (Paths.subtermEdgePath x))}, - Core.Field { - Core.fieldName = (Core.Name "target"), - Core.fieldTerm = (subtermNode (Paths.subtermEdgeTarget x))}]}) - -subtermGraph :: Paths.SubtermGraph -> Core.Term -subtermGraph x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.paths.SubtermGraph"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "nodes"), - Core.fieldTerm = ((\xs -> Core.TermList (Lists.map subtermNode xs)) (Paths.subtermGraphNodes x))}, - Core.Field { - Core.fieldName = (Core.Name "edges"), - Core.fieldTerm = ((\xs -> Core.TermList (Lists.map subtermEdge xs)) (Paths.subtermGraphEdges x))}]}) - -subtermNode :: Paths.SubtermNode -> Core.Term -subtermNode x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.paths.SubtermNode"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core_.name (Paths.subtermNodeName x))}, - Core.Field { - Core.fieldName = (Core.Name "label"), - Core.fieldTerm = ((\x -> Core.TermLiteral (Core.LiteralString x)) (Paths.subtermNodeLabel x))}, - Core.Field { - Core.fieldName = (Core.Name "id"), - Core.fieldTerm = ((\x -> Core.TermLiteral (Core.LiteralString x)) (Paths.subtermNodeId x))}]}) - -subtermPath :: Paths.SubtermPath -> Core.Term -subtermPath x = - Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.paths.SubtermPath"), - Core.wrappedTermBody = ((\xs -> Core.TermList (Lists.map subtermStep xs)) (Paths.unSubtermPath x))}) - -subtermStep :: Paths.SubtermStep -> Core.Term -subtermStep x = - case x of - Paths.SubtermStepAnnotatedBody -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "annotatedBody"), - Core.fieldTerm = Core.TermUnit}}) - Paths.SubtermStepApplicationFunction -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "applicationFunction"), - Core.fieldTerm = Core.TermUnit}}) - Paths.SubtermStepApplicationArgument -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "applicationArgument"), - Core.fieldTerm = Core.TermUnit}}) - Paths.SubtermStepLambdaBody -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "lambdaBody"), - Core.fieldTerm = Core.TermUnit}}) - Paths.SubtermStepUnionCasesDefault -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unionCasesDefault"), - Core.fieldTerm = Core.TermUnit}}) - Paths.SubtermStepUnionCasesBranch v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unionCasesBranch"), - Core.fieldTerm = (Core_.name v0)}}) - Paths.SubtermStepLetBody -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "letBody"), - Core.fieldTerm = Core.TermUnit}}) - Paths.SubtermStepLetBinding v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "letBinding"), - Core.fieldTerm = (Core_.name v0)}}) - Paths.SubtermStepListElement v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "listElement"), - Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 v0)))}}) - Paths.SubtermStepMapKey v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "mapKey"), - Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 v0)))}}) - Paths.SubtermStepMapValue v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "mapValue"), - Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 v0)))}}) - Paths.SubtermStepMaybeTerm -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "maybeTerm"), - Core.fieldTerm = Core.TermUnit}}) - Paths.SubtermStepProductTerm v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "productTerm"), - Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 v0)))}}) - Paths.SubtermStepRecordField v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "recordField"), - Core.fieldTerm = (Core_.name v0)}}) - Paths.SubtermStepSetElement v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "setElement"), - Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 v0)))}}) - Paths.SubtermStepSumTerm -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "sumTerm"), - Core.fieldTerm = Core.TermUnit}}) - Paths.SubtermStepTypeLambdaBody -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "typeLambdaBody"), - Core.fieldTerm = Core.TermUnit}}) - Paths.SubtermStepTypeApplicationTerm -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "typeApplicationTerm"), - Core.fieldTerm = Core.TermUnit}}) - Paths.SubtermStepInjectionTerm -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "injectionTerm"), - Core.fieldTerm = Core.TermUnit}}) - Paths.SubtermStepWrappedTerm -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wrappedTerm"), - Core.fieldTerm = Core.TermUnit}}) - -subtypeEdge :: Paths.SubtypeEdge -> Core.Term -subtypeEdge x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.paths.SubtypeEdge"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "source"), - Core.fieldTerm = (subtypeNode (Paths.subtypeEdgeSource x))}, - Core.Field { - Core.fieldName = (Core.Name "path"), - Core.fieldTerm = (subtypePath (Paths.subtypeEdgePath x))}, - Core.Field { - Core.fieldName = (Core.Name "target"), - Core.fieldTerm = (subtypeNode (Paths.subtypeEdgeTarget x))}]}) - -subtypeGraph :: Paths.SubtypeGraph -> Core.Term -subtypeGraph x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.paths.SubtypeGraph"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "nodes"), - Core.fieldTerm = ((\xs -> Core.TermList (Lists.map subtypeNode xs)) (Paths.subtypeGraphNodes x))}, - Core.Field { - Core.fieldName = (Core.Name "edges"), - Core.fieldTerm = ((\xs -> Core.TermList (Lists.map subtypeEdge xs)) (Paths.subtypeGraphEdges x))}]}) - -subtypeNode :: Paths.SubtypeNode -> Core.Term -subtypeNode x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.paths.SubtypeNode"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core_.name (Paths.subtypeNodeName x))}, - Core.Field { - Core.fieldName = (Core.Name "label"), - Core.fieldTerm = ((\x -> Core.TermLiteral (Core.LiteralString x)) (Paths.subtypeNodeLabel x))}, - Core.Field { - Core.fieldName = (Core.Name "id"), - Core.fieldTerm = ((\x -> Core.TermLiteral (Core.LiteralString x)) (Paths.subtypeNodeId x))}]}) - -subtypePath :: Paths.SubtypePath -> Core.Term -subtypePath x = - Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.paths.SubtypePath"), - Core.wrappedTermBody = ((\xs -> Core.TermList (Lists.map subtypeStep xs)) (Paths.unSubtypePath x))}) - -subtypeStep :: Paths.SubtypeStep -> Core.Term -subtypeStep x = - case x of - Paths.SubtypeStepAnnotatedBody -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "annotatedBody"), - Core.fieldTerm = Core.TermUnit}}) - Paths.SubtypeStepApplicationFunction -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "applicationFunction"), - Core.fieldTerm = Core.TermUnit}}) - Paths.SubtypeStepApplicationArgument -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "applicationArgument"), - Core.fieldTerm = Core.TermUnit}}) - Paths.SubtypeStepEitherLeft -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "eitherLeft"), - Core.fieldTerm = Core.TermUnit}}) - Paths.SubtypeStepEitherRight -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "eitherRight"), - Core.fieldTerm = Core.TermUnit}}) - Paths.SubtypeStepForallBody -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "forallBody"), - Core.fieldTerm = Core.TermUnit}}) - Paths.SubtypeStepFunctionDomain -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "functionDomain"), - Core.fieldTerm = Core.TermUnit}}) - Paths.SubtypeStepFunctionCodomain -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "functionCodomain"), - Core.fieldTerm = Core.TermUnit}}) - Paths.SubtypeStepListElement -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "listElement"), - Core.fieldTerm = Core.TermUnit}}) - Paths.SubtypeStepMapKeys -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "mapKeys"), - Core.fieldTerm = Core.TermUnit}}) - Paths.SubtypeStepMapValues -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "mapValues"), - Core.fieldTerm = Core.TermUnit}}) - Paths.SubtypeStepMaybeElement -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "maybeElement"), - Core.fieldTerm = Core.TermUnit}}) - Paths.SubtypeStepPairFirst -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "pairFirst"), - Core.fieldTerm = Core.TermUnit}}) - Paths.SubtypeStepPairSecond -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "pairSecond"), - Core.fieldTerm = Core.TermUnit}}) - Paths.SubtypeStepRecordField v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "recordField"), - Core.fieldTerm = (Core_.name v0)}}) - Paths.SubtypeStepSetElement -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "setElement"), - Core.fieldTerm = Core.TermUnit}}) - Paths.SubtypeStepUnionField v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unionField"), - Core.fieldTerm = (Core_.name v0)}}) - Paths.SubtypeStepWrappedType -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wrappedType"), - Core.fieldTerm = Core.TermUnit}}) diff --git a/src/gen-main/haskell/Hydra/Encode/Phantoms.hs b/src/gen-main/haskell/Hydra/Encode/Phantoms.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Encode/Phantoms.hs +++ /dev/null @@ -1,33 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Term encoders for hydra.phantoms - -module Hydra.Encode.Phantoms where - -import qualified Hydra.Core as Core -import qualified Hydra.Encode.Core as Core_ -import qualified Hydra.Phantoms as Phantoms -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -tBinding :: t0 -> Phantoms.TBinding t1 -> Core.Term -tBinding a x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.phantoms.TBinding"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core_.name (Phantoms.tBindingName x))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (tTerm a (Phantoms.tBindingTerm x))}]}) - -tTerm :: t0 -> Phantoms.TTerm t1 -> Core.Term -tTerm a x = - Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.phantoms.TTerm"), - Core.wrappedTermBody = (Core_.term (Phantoms.unTTerm x))}) diff --git a/src/gen-main/haskell/Hydra/Encode/Query.hs b/src/gen-main/haskell/Hydra/Encode/Query.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Encode/Query.hs +++ /dev/null @@ -1,284 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Term encoders for hydra.query - -module Hydra.Encode.Query where - -import qualified Hydra.Core as Core -import qualified Hydra.Encode.Core as Core_ -import qualified Hydra.Lib.Lists as Lists -import qualified Hydra.Lib.Maybes as Maybes -import qualified Hydra.Query as Query -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -comparisonConstraint :: Query.ComparisonConstraint -> Core.Term -comparisonConstraint x = - case x of - Query.ComparisonConstraintEqual -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.ComparisonConstraint"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "equal"), - Core.fieldTerm = Core.TermUnit}}) - Query.ComparisonConstraintNotEqual -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.ComparisonConstraint"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "notEqual"), - Core.fieldTerm = Core.TermUnit}}) - Query.ComparisonConstraintLessThan -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.ComparisonConstraint"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "lessThan"), - Core.fieldTerm = Core.TermUnit}}) - Query.ComparisonConstraintGreaterThan -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.ComparisonConstraint"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "greaterThan"), - Core.fieldTerm = Core.TermUnit}}) - Query.ComparisonConstraintLessThanOrEqual -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.ComparisonConstraint"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "lessThanOrEqual"), - Core.fieldTerm = Core.TermUnit}}) - Query.ComparisonConstraintGreaterThanOrEqual -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.ComparisonConstraint"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "greaterThanOrEqual"), - Core.fieldTerm = Core.TermUnit}}) - -edge :: Query.Edge -> Core.Term -edge x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.query.Edge"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core_.name (Query.edgeType x))}, - Core.Field { - Core.fieldName = (Core.Name "out"), - Core.fieldTerm = ((\opt -> Core.TermMaybe (Maybes.map Core_.name opt)) (Query.edgeOut x))}, - Core.Field { - Core.fieldName = (Core.Name "in"), - Core.fieldTerm = ((\opt -> Core.TermMaybe (Maybes.map Core_.name opt)) (Query.edgeIn x))}]}) - -graphPattern :: Query.GraphPattern -> Core.Term -graphPattern x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.query.GraphPattern"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "graph"), - Core.fieldTerm = (Core_.name (Query.graphPatternGraph x))}, - Core.Field { - Core.fieldName = (Core.Name "patterns"), - Core.fieldTerm = ((\xs -> Core.TermList (Lists.map pattern xs)) (Query.graphPatternPatterns x))}]}) - -node :: Query.Node -> Core.Term -node x = - case x of - Query.NodeTerm v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.Node"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core_.term v0)}}) - Query.NodeVariable v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.Node"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "variable"), - Core.fieldTerm = (variable v0)}}) - Query.NodeWildcard -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.Node"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wildcard"), - Core.fieldTerm = Core.TermUnit}}) - -path :: Query.Path -> Core.Term -path x = - case x of - Query.PathStep v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.Path"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "step"), - Core.fieldTerm = (step v0)}}) - Query.PathRegex v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.Path"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "regex"), - Core.fieldTerm = (regexSequence v0)}}) - Query.PathInverse v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.Path"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inverse"), - Core.fieldTerm = (path v0)}}) - -pathEquation :: Query.PathEquation -> Core.Term -pathEquation x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.query.PathEquation"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "left"), - Core.fieldTerm = (path (Query.pathEquationLeft x))}, - Core.Field { - Core.fieldName = (Core.Name "right"), - Core.fieldTerm = (path (Query.pathEquationRight x))}]}) - -pattern :: Query.Pattern -> Core.Term -pattern x = - case x of - Query.PatternTriple v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.Pattern"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "triple"), - Core.fieldTerm = (triplePattern v0)}}) - Query.PatternNegation v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.Pattern"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "negation"), - Core.fieldTerm = (pattern v0)}}) - Query.PatternConjunction v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.Pattern"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "conjunction"), - Core.fieldTerm = (Core.TermList (Lists.map pattern v0))}}) - Query.PatternDisjunction v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.Pattern"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "disjunction"), - Core.fieldTerm = (Core.TermList (Lists.map pattern v0))}}) - Query.PatternGraph v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.Pattern"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "graph"), - Core.fieldTerm = (graphPattern v0)}}) - -patternImplication :: Query.PatternImplication -> Core.Term -patternImplication x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.query.PatternImplication"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "antecedent"), - Core.fieldTerm = (pattern (Query.patternImplicationAntecedent x))}, - Core.Field { - Core.fieldName = (Core.Name "consequent"), - Core.fieldTerm = (pattern (Query.patternImplicationConsequent x))}]}) - -query :: Query.Query -> Core.Term -query x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.query.Query"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "variables"), - Core.fieldTerm = ((\xs -> Core.TermList (Lists.map variable xs)) (Query.queryVariables x))}, - Core.Field { - Core.fieldName = (Core.Name "patterns"), - Core.fieldTerm = ((\xs -> Core.TermList (Lists.map pattern xs)) (Query.queryPatterns x))}]}) - -range :: Query.Range -> Core.Term -range x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.query.Range"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "min"), - Core.fieldTerm = ((\x -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x))) (Query.rangeMin x))}, - Core.Field { - Core.fieldName = (Core.Name "max"), - Core.fieldTerm = ((\x -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x))) (Query.rangeMax x))}]}) - -regexQuantifier :: Query.RegexQuantifier -> Core.Term -regexQuantifier x = - case x of - Query.RegexQuantifierOne -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.RegexQuantifier"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "one"), - Core.fieldTerm = Core.TermUnit}}) - Query.RegexQuantifierZeroOrOne -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.RegexQuantifier"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "zeroOrOne"), - Core.fieldTerm = Core.TermUnit}}) - Query.RegexQuantifierZeroOrMore -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.RegexQuantifier"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "zeroOrMore"), - Core.fieldTerm = Core.TermUnit}}) - Query.RegexQuantifierOneOrMore -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.RegexQuantifier"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "oneOrMore"), - Core.fieldTerm = Core.TermUnit}}) - Query.RegexQuantifierExactly v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.RegexQuantifier"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "exactly"), - Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 v0)))}}) - Query.RegexQuantifierAtLeast v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.RegexQuantifier"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "atLeast"), - Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 v0)))}}) - Query.RegexQuantifierRange v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.RegexQuantifier"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "range"), - Core.fieldTerm = (range v0)}}) - -regexSequence :: Query.RegexSequence -> Core.Term -regexSequence x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.query.RegexSequence"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "path"), - Core.fieldTerm = (path (Query.regexSequencePath x))}, - Core.Field { - Core.fieldName = (Core.Name "quantifier"), - Core.fieldTerm = (regexQuantifier (Query.regexSequenceQuantifier x))}]}) - -step :: Query.Step -> Core.Term -step x = - case x of - Query.StepEdge v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.Step"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "edge"), - Core.fieldTerm = (edge v0)}}) - Query.StepProject v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.Step"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "project"), - Core.fieldTerm = (Core_.projection v0)}}) - Query.StepCompare v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.query.Step"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "compare"), - Core.fieldTerm = (comparisonConstraint v0)}}) - -triplePattern :: Query.TriplePattern -> Core.Term -triplePattern x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.query.TriplePattern"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "subject"), - Core.fieldTerm = (node (Query.triplePatternSubject x))}, - Core.Field { - Core.fieldName = (Core.Name "predicate"), - Core.fieldTerm = (path (Query.triplePatternPredicate x))}, - Core.Field { - Core.fieldName = (Core.Name "object"), - Core.fieldTerm = (node (Query.triplePatternObject x))}]}) - -variable :: Query.Variable -> Core.Term -variable x = - Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.query.Variable"), - Core.wrappedTermBody = ((\x -> Core.TermLiteral (Core.LiteralString x)) (Query.unVariable x))}) diff --git a/src/gen-main/haskell/Hydra/Encode/Relational.hs b/src/gen-main/haskell/Hydra/Encode/Relational.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Encode/Relational.hs +++ /dev/null @@ -1,95 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Term encoders for hydra.relational - -module Hydra.Encode.Relational where - -import qualified Hydra.Core as Core -import qualified Hydra.Lib.Lists as Lists -import qualified Hydra.Lib.Maps as Maps -import qualified Hydra.Lib.Sets as Sets -import qualified Hydra.Relational as Relational -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -columnName :: Relational.ColumnName -> Core.Term -columnName x = - Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.relational.ColumnName"), - Core.wrappedTermBody = ((\x -> Core.TermLiteral (Core.LiteralString x)) (Relational.unColumnName x))}) - -columnSchema :: (t0 -> Core.Term) -> Relational.ColumnSchema t0 -> Core.Term -columnSchema t x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.relational.ColumnSchema"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (columnName (Relational.columnSchemaName x))}, - Core.Field { - Core.fieldName = (Core.Name "domain"), - Core.fieldTerm = (t (Relational.columnSchemaDomain x))}]}) - -foreignKey :: Relational.ForeignKey -> Core.Term -foreignKey x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.relational.ForeignKey"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "foreignRelation"), - Core.fieldTerm = (relationName (Relational.foreignKeyForeignRelation x))}, - Core.Field { - Core.fieldName = (Core.Name "keys"), - Core.fieldTerm = ((\m -> Core.TermMap (Maps.bimap columnName columnName m)) (Relational.foreignKeyKeys x))}]}) - -primaryKey :: Relational.PrimaryKey -> Core.Term -primaryKey x = - Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.relational.PrimaryKey"), - Core.wrappedTermBody = ((\xs -> Core.TermList (Lists.map columnName xs)) (Relational.unPrimaryKey x))}) - -relation :: (t0 -> Core.Term) -> Relational.Relation t0 -> Core.Term -relation v x = - Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.relational.Relation"), - Core.wrappedTermBody = ((\xs -> Core.TermList (Lists.map (row v) xs)) (Relational.unRelation x))}) - -relationName :: Relational.RelationName -> Core.Term -relationName x = - Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.relational.RelationName"), - Core.wrappedTermBody = ((\x -> Core.TermLiteral (Core.LiteralString x)) (Relational.unRelationName x))}) - -relationSchema :: (t0 -> Core.Term) -> Relational.RelationSchema t0 -> Core.Term -relationSchema t x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.relational.RelationSchema"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (relationName (Relational.relationSchemaName x))}, - Core.Field { - Core.fieldName = (Core.Name "columns"), - Core.fieldTerm = ((\xs -> Core.TermList (Lists.map (columnSchema t) xs)) (Relational.relationSchemaColumns x))}, - Core.Field { - Core.fieldName = (Core.Name "primaryKeys"), - Core.fieldTerm = ((\xs -> Core.TermList (Lists.map primaryKey xs)) (Relational.relationSchemaPrimaryKeys x))}, - Core.Field { - Core.fieldName = (Core.Name "foreignKeys"), - Core.fieldTerm = ((\xs -> Core.TermList (Lists.map foreignKey xs)) (Relational.relationSchemaForeignKeys x))}]}) - -relationship :: Ord t0 => ((t0 -> Core.Term) -> Relational.Relationship t0 -> Core.Term) -relationship v x = - Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.relational.Relationship"), - Core.wrappedTermBody = ((\s -> Core.TermSet (Sets.map (\m -> Core.TermMap (Maps.bimap columnName v m)) s)) (Relational.unRelationship x))}) - -row :: (t0 -> Core.Term) -> Relational.Row t0 -> Core.Term -row v x = - Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.relational.Row"), - Core.wrappedTermBody = ((\xs -> Core.TermList (Lists.map v xs)) (Relational.unRow x))}) diff --git a/src/gen-main/haskell/Hydra/Encode/Tabular.hs b/src/gen-main/haskell/Hydra/Encode/Tabular.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Encode/Tabular.hs +++ /dev/null @@ -1,66 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Term encoders for hydra.tabular - -module Hydra.Encode.Tabular where - -import qualified Hydra.Core as Core -import qualified Hydra.Encode.Core as Core_ -import qualified Hydra.Encode.Relational as Relational -import qualified Hydra.Lib.Lists as Lists -import qualified Hydra.Lib.Maybes as Maybes -import qualified Hydra.Tabular as Tabular -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -columnType :: Tabular.ColumnType -> Core.Term -columnType x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.tabular.ColumnType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Relational.columnName (Tabular.columnTypeName x))}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core_.type_ (Tabular.columnTypeType x))}]}) - -dataRow :: (t0 -> Core.Term) -> Tabular.DataRow t0 -> Core.Term -dataRow v x = - Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.tabular.DataRow"), - Core.wrappedTermBody = ((\xs -> Core.TermList (Lists.map (\opt -> Core.TermMaybe (Maybes.map v opt)) xs)) (Tabular.unDataRow x))}) - -headerRow :: Tabular.HeaderRow -> Core.Term -headerRow x = - Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.tabular.HeaderRow"), - Core.wrappedTermBody = ((\xs -> Core.TermList (Lists.map (\x -> Core.TermLiteral (Core.LiteralString x)) xs)) (Tabular.unHeaderRow x))}) - -table :: (t0 -> Core.Term) -> Tabular.Table t0 -> Core.Term -table v x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.tabular.Table"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "header"), - Core.fieldTerm = ((\opt -> Core.TermMaybe (Maybes.map headerRow opt)) (Tabular.tableHeader x))}, - Core.Field { - Core.fieldName = (Core.Name "data"), - Core.fieldTerm = ((\xs -> Core.TermList (Lists.map (dataRow v) xs)) (Tabular.tableData x))}]}) - -tableType :: Tabular.TableType -> Core.Term -tableType x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.tabular.TableType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Relational.relationName (Tabular.tableTypeName x))}, - Core.Field { - Core.fieldName = (Core.Name "columns"), - Core.fieldTerm = ((\xs -> Core.TermList (Lists.map columnType xs)) (Tabular.tableTypeColumns x))}]}) diff --git a/src/gen-main/haskell/Hydra/Encode/Testing.hs b/src/gen-main/haskell/Hydra/Encode/Testing.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Encode/Testing.hs +++ /dev/null @@ -1,871 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Term encoders for hydra.testing - -module Hydra.Encode.Testing where - -import qualified Hydra.Core as Core -import qualified Hydra.Encode.Ast as Ast -import qualified Hydra.Encode.Coders as Coders -import qualified Hydra.Encode.Core as Core_ -import qualified Hydra.Encode.Error.Core as Core__ -import qualified Hydra.Encode.Json.Model as Model -import qualified Hydra.Encode.Parsing as Parsing -import qualified Hydra.Encode.Typing as Typing -import qualified Hydra.Encode.Util as Util -import qualified Hydra.Json.Model as Model_ -import qualified Hydra.Lib.Eithers as Eithers -import qualified Hydra.Lib.Lists as Lists -import qualified Hydra.Lib.Maybes as Maybes -import qualified Hydra.Lib.Pairs as Pairs -import qualified Hydra.Lib.Sets as Sets -import qualified Hydra.Testing as Testing -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -alphaConversionTestCase :: Testing.AlphaConversionTestCase -> Core.Term -alphaConversionTestCase x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.AlphaConversionTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core_.term (Testing.alphaConversionTestCaseTerm x))}, - Core.Field { - Core.fieldName = (Core.Name "oldVariable"), - Core.fieldTerm = (Core_.name (Testing.alphaConversionTestCaseOldVariable x))}, - Core.Field { - Core.fieldName = (Core.Name "newVariable"), - Core.fieldTerm = (Core_.name (Testing.alphaConversionTestCaseNewVariable x))}, - Core.Field { - Core.fieldName = (Core.Name "result"), - Core.fieldTerm = (Core_.term (Testing.alphaConversionTestCaseResult x))}]}) - -caseConversionTestCase :: Testing.CaseConversionTestCase -> Core.Term -caseConversionTestCase x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.CaseConversionTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "fromConvention"), - Core.fieldTerm = (Util.caseConvention (Testing.caseConversionTestCaseFromConvention x))}, - Core.Field { - Core.fieldName = (Core.Name "toConvention"), - Core.fieldTerm = (Util.caseConvention (Testing.caseConversionTestCaseToConvention x))}, - Core.Field { - Core.fieldName = (Core.Name "fromString"), - Core.fieldTerm = ((\x -> Core.TermLiteral (Core.LiteralString x)) (Testing.caseConversionTestCaseFromString x))}, - Core.Field { - Core.fieldName = (Core.Name "toString"), - Core.fieldTerm = ((\x -> Core.TermLiteral (Core.LiteralString x)) (Testing.caseConversionTestCaseToString x))}]}) - -deannotateTermTestCase :: Testing.DeannotateTermTestCase -> Core.Term -deannotateTermTestCase x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.DeannotateTermTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core_.term (Testing.deannotateTermTestCaseInput x))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Core_.term (Testing.deannotateTermTestCaseOutput x))}]}) - -deannotateTypeTestCase :: Testing.DeannotateTypeTestCase -> Core.Term -deannotateTypeTestCase x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.DeannotateTypeTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core_.type_ (Testing.deannotateTypeTestCaseInput x))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Core_.type_ (Testing.deannotateTypeTestCaseOutput x))}]}) - -delegatedEvaluationTestCase :: Testing.DelegatedEvaluationTestCase -> Core.Term -delegatedEvaluationTestCase x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.DelegatedEvaluationTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core_.term (Testing.delegatedEvaluationTestCaseInput x))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Core_.term (Testing.delegatedEvaluationTestCaseOutput x))}]}) - -etaExpansionTestCase :: Testing.EtaExpansionTestCase -> Core.Term -etaExpansionTestCase x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.EtaExpansionTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core_.term (Testing.etaExpansionTestCaseInput x))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Core_.term (Testing.etaExpansionTestCaseOutput x))}]}) - -evaluationStyle :: Testing.EvaluationStyle -> Core.Term -evaluationStyle x = - case x of - Testing.EvaluationStyleEager -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.EvaluationStyle"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "eager"), - Core.fieldTerm = Core.TermUnit}}) - Testing.EvaluationStyleLazy -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.EvaluationStyle"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "lazy"), - Core.fieldTerm = Core.TermUnit}}) - -evaluationTestCase :: Testing.EvaluationTestCase -> Core.Term -evaluationTestCase x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.EvaluationTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "evaluationStyle"), - Core.fieldTerm = (evaluationStyle (Testing.evaluationTestCaseEvaluationStyle x))}, - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core_.term (Testing.evaluationTestCaseInput x))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Core_.term (Testing.evaluationTestCaseOutput x))}]}) - -flattenLetTermsTestCase :: Testing.FlattenLetTermsTestCase -> Core.Term -flattenLetTermsTestCase x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.FlattenLetTermsTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core_.term (Testing.flattenLetTermsTestCaseInput x))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Core_.term (Testing.flattenLetTermsTestCaseOutput x))}]}) - -foldOperation :: Testing.FoldOperation -> Core.Term -foldOperation x = - case x of - Testing.FoldOperationSumInt32Literals -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.FoldOperation"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "sumInt32Literals"), - Core.fieldTerm = Core.TermUnit}}) - Testing.FoldOperationCollectListLengths -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.FoldOperation"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "collectListLengths"), - Core.fieldTerm = Core.TermUnit}}) - Testing.FoldOperationCollectLabels -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.FoldOperation"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "collectLabels"), - Core.fieldTerm = Core.TermUnit}}) - -foldOverTermTestCase :: Testing.FoldOverTermTestCase -> Core.Term -foldOverTermTestCase x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.FoldOverTermTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core_.term (Testing.foldOverTermTestCaseInput x))}, - Core.Field { - Core.fieldName = (Core.Name "traversalOrder"), - Core.fieldTerm = (Coders.traversalOrder (Testing.foldOverTermTestCaseTraversalOrder x))}, - Core.Field { - Core.fieldName = (Core.Name "operation"), - Core.fieldTerm = (foldOperation (Testing.foldOverTermTestCaseOperation x))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Core_.term (Testing.foldOverTermTestCaseOutput x))}]}) - -freeVariablesTestCase :: Testing.FreeVariablesTestCase -> Core.Term -freeVariablesTestCase x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.FreeVariablesTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core_.term (Testing.freeVariablesTestCaseInput x))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = ((\s -> Core.TermSet (Sets.map Core_.name s)) (Testing.freeVariablesTestCaseOutput x))}]}) - -hoistCaseStatementsTestCase :: Testing.HoistCaseStatementsTestCase -> Core.Term -hoistCaseStatementsTestCase x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.HoistCaseStatementsTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core_.term (Testing.hoistCaseStatementsTestCaseInput x))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Core_.term (Testing.hoistCaseStatementsTestCaseOutput x))}]}) - -hoistLetBindingsTestCase :: Testing.HoistLetBindingsTestCase -> Core.Term -hoistLetBindingsTestCase x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.HoistLetBindingsTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core_.let_ (Testing.hoistLetBindingsTestCaseInput x))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Core_.let_ (Testing.hoistLetBindingsTestCaseOutput x))}]}) - -hoistPolymorphicLetBindingsTestCase :: Testing.HoistPolymorphicLetBindingsTestCase -> Core.Term -hoistPolymorphicLetBindingsTestCase x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.HoistPolymorphicLetBindingsTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core_.let_ (Testing.hoistPolymorphicLetBindingsTestCaseInput x))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Core_.let_ (Testing.hoistPolymorphicLetBindingsTestCaseOutput x))}]}) - -hoistPredicate :: Testing.HoistPredicate -> Core.Term -hoistPredicate x = - case x of - Testing.HoistPredicateCaseStatements -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.HoistPredicate"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "caseStatements"), - Core.fieldTerm = Core.TermUnit}}) - Testing.HoistPredicateApplications -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.HoistPredicate"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "applications"), - Core.fieldTerm = Core.TermUnit}}) - Testing.HoistPredicateLists -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.HoistPredicate"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "lists"), - Core.fieldTerm = Core.TermUnit}}) - Testing.HoistPredicateNothing -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.HoistPredicate"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "nothing"), - Core.fieldTerm = Core.TermUnit}}) - -hoistSubtermsTestCase :: Testing.HoistSubtermsTestCase -> Core.Term -hoistSubtermsTestCase x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.HoistSubtermsTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "predicate"), - Core.fieldTerm = (hoistPredicate (Testing.hoistSubtermsTestCasePredicate x))}, - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core_.term (Testing.hoistSubtermsTestCaseInput x))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Core_.term (Testing.hoistSubtermsTestCaseOutput x))}]}) - -inferenceFailureTestCase :: Testing.InferenceFailureTestCase -> Core.Term -inferenceFailureTestCase x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.InferenceFailureTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core_.term (Testing.inferenceFailureTestCaseInput x))}]}) - -inferenceTestCase :: Testing.InferenceTestCase -> Core.Term -inferenceTestCase x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.InferenceTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core_.term (Testing.inferenceTestCaseInput x))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Core_.typeScheme (Testing.inferenceTestCaseOutput x))}]}) - -joinTypesTestCase :: Testing.JoinTypesTestCase -> Core.Term -joinTypesTestCase x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.JoinTypesTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "left"), - Core.fieldTerm = (Core_.type_ (Testing.joinTypesTestCaseLeft x))}, - Core.Field { - Core.fieldName = (Core.Name "right"), - Core.fieldTerm = (Core_.type_ (Testing.joinTypesTestCaseRight x))}, - Core.Field { - Core.fieldName = (Core.Name "expected"), - Core.fieldTerm = ((\e -> Core.TermEither (Eithers.bimap (\_ -> Core.TermUnit) (\xs -> Core.TermList (Lists.map Typing.typeConstraint xs)) e)) (Testing.joinTypesTestCaseExpected x))}]}) - -jsonDecodeTestCase :: Testing.JsonDecodeTestCase -> Core.Term -jsonDecodeTestCase x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.JsonDecodeTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core_.type_ (Testing.jsonDecodeTestCaseType x))}, - Core.Field { - Core.fieldName = (Core.Name "json"), - Core.fieldTerm = (Model.value (Testing.jsonDecodeTestCaseJson x))}, - Core.Field { - Core.fieldName = (Core.Name "expected"), - Core.fieldTerm = ((\e -> Core.TermEither (Eithers.bimap (\x -> Core.TermLiteral (Core.LiteralString x)) Core_.term e)) (Testing.jsonDecodeTestCaseExpected x))}]}) - -jsonEncodeTestCase :: Testing.JsonEncodeTestCase -> Core.Term -jsonEncodeTestCase x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.JsonEncodeTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core_.term (Testing.jsonEncodeTestCaseTerm x))}, - Core.Field { - Core.fieldName = (Core.Name "expected"), - Core.fieldTerm = ((\e -> Core.TermEither (Eithers.bimap (\x -> Core.TermLiteral (Core.LiteralString x)) Model.value e)) (Testing.jsonEncodeTestCaseExpected x))}]}) - -jsonParserTestCase :: Testing.ParserTestCase Model_.Value -> Core.Term -jsonParserTestCase = parserTestCase Model.value - -jsonRoundtripTestCase :: Testing.JsonRoundtripTestCase -> Core.Term -jsonRoundtripTestCase x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.JsonRoundtripTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core_.type_ (Testing.jsonRoundtripTestCaseType x))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core_.term (Testing.jsonRoundtripTestCaseTerm x))}]}) - -jsonWriterTestCase :: Testing.WriterTestCase Model_.Value -> Core.Term -jsonWriterTestCase = writerTestCase Model.value - -liftLambdaAboveLetTestCase :: Testing.LiftLambdaAboveLetTestCase -> Core.Term -liftLambdaAboveLetTestCase x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.LiftLambdaAboveLetTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core_.term (Testing.liftLambdaAboveLetTestCaseInput x))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Core_.term (Testing.liftLambdaAboveLetTestCaseOutput x))}]}) - -normalizeTypeVariablesTestCase :: Testing.NormalizeTypeVariablesTestCase -> Core.Term -normalizeTypeVariablesTestCase x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.NormalizeTypeVariablesTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core_.term (Testing.normalizeTypeVariablesTestCaseInput x))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Core_.term (Testing.normalizeTypeVariablesTestCaseOutput x))}]}) - -parserTestCase :: (t0 -> Core.Term) -> Testing.ParserTestCase t0 -> Core.Term -parserTestCase a x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.ParserTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = ((\x -> Core.TermLiteral (Core.LiteralString x)) (Testing.parserTestCaseInput x))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Parsing.parseResult a (Testing.parserTestCaseOutput x))}]}) - -rewriteTermTestCase :: Testing.RewriteTermTestCase -> Core.Term -rewriteTermTestCase x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.RewriteTermTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core_.term (Testing.rewriteTermTestCaseInput x))}, - Core.Field { - Core.fieldName = (Core.Name "rewriter"), - Core.fieldTerm = (termRewriter (Testing.rewriteTermTestCaseRewriter x))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Core_.term (Testing.rewriteTermTestCaseOutput x))}]}) - -rewriteTypeTestCase :: Testing.RewriteTypeTestCase -> Core.Term -rewriteTypeTestCase x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.RewriteTypeTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core_.type_ (Testing.rewriteTypeTestCaseInput x))}, - Core.Field { - Core.fieldName = (Core.Name "rewriter"), - Core.fieldTerm = (typeRewriter (Testing.rewriteTypeTestCaseRewriter x))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Core_.type_ (Testing.rewriteTypeTestCaseOutput x))}]}) - -serializationTestCase :: Testing.SerializationTestCase -> Core.Term -serializationTestCase x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.SerializationTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Ast.expr (Testing.serializationTestCaseInput x))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = ((\x -> Core.TermLiteral (Core.LiteralString x)) (Testing.serializationTestCaseOutput x))}]}) - -simplifyTermTestCase :: Testing.SimplifyTermTestCase -> Core.Term -simplifyTermTestCase x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.SimplifyTermTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core_.term (Testing.simplifyTermTestCaseInput x))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Core_.term (Testing.simplifyTermTestCaseOutput x))}]}) - -substInTypeTestCase :: Testing.SubstInTypeTestCase -> Core.Term -substInTypeTestCase x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.SubstInTypeTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "substitution"), - Core.fieldTerm = ((\xs -> Core.TermList (Lists.map (\p -> Core.TermPair (Pairs.bimap Core_.name Core_.type_ p)) xs)) (Testing.substInTypeTestCaseSubstitution x))}, - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core_.type_ (Testing.substInTypeTestCaseInput x))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Core_.type_ (Testing.substInTypeTestCaseOutput x))}]}) - -tag :: Testing.Tag -> Core.Term -tag x = - Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.testing.Tag"), - Core.wrappedTermBody = ((\x -> Core.TermLiteral (Core.LiteralString x)) (Testing.unTag x))}) - -termRewriter :: Testing.TermRewriter -> Core.Term -termRewriter x = - case x of - Testing.TermRewriterReplaceFooWithBar -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TermRewriter"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "replaceFooWithBar"), - Core.fieldTerm = Core.TermUnit}}) - Testing.TermRewriterReplaceInt32WithInt64 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TermRewriter"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "replaceInt32WithInt64"), - Core.fieldTerm = Core.TermUnit}}) - -testCase :: Testing.TestCase -> Core.Term -testCase x = - case x of - Testing.TestCaseAlphaConversion v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "alphaConversion"), - Core.fieldTerm = (alphaConversionTestCase v0)}}) - Testing.TestCaseCaseConversion v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "caseConversion"), - Core.fieldTerm = (caseConversionTestCase v0)}}) - Testing.TestCaseDeannotateTerm v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "deannotateTerm"), - Core.fieldTerm = (deannotateTermTestCase v0)}}) - Testing.TestCaseDeannotateType v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "deannotateType"), - Core.fieldTerm = (deannotateTypeTestCase v0)}}) - Testing.TestCaseDelegatedEvaluation v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "delegatedEvaluation"), - Core.fieldTerm = (delegatedEvaluationTestCase v0)}}) - Testing.TestCaseEtaExpansion v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "etaExpansion"), - Core.fieldTerm = (etaExpansionTestCase v0)}}) - Testing.TestCaseFlattenLetTerms v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "flattenLetTerms"), - Core.fieldTerm = (flattenLetTermsTestCase v0)}}) - Testing.TestCaseFreeVariables v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "freeVariables"), - Core.fieldTerm = (freeVariablesTestCase v0)}}) - Testing.TestCaseEvaluation v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "evaluation"), - Core.fieldTerm = (evaluationTestCase v0)}}) - Testing.TestCaseInference v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inference"), - Core.fieldTerm = (inferenceTestCase v0)}}) - Testing.TestCaseInferenceFailure v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "inferenceFailure"), - Core.fieldTerm = (inferenceFailureTestCase v0)}}) - Testing.TestCaseJsonDecode v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "jsonDecode"), - Core.fieldTerm = (jsonDecodeTestCase v0)}}) - Testing.TestCaseJsonEncode v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "jsonEncode"), - Core.fieldTerm = (jsonEncodeTestCase v0)}}) - Testing.TestCaseJsonParser v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "jsonParser"), - Core.fieldTerm = (jsonParserTestCase v0)}}) - Testing.TestCaseJsonRoundtrip v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "jsonRoundtrip"), - Core.fieldTerm = (jsonRoundtripTestCase v0)}}) - Testing.TestCaseJsonWriter v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "jsonWriter"), - Core.fieldTerm = (jsonWriterTestCase v0)}}) - Testing.TestCaseLiftLambdaAboveLet v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "liftLambdaAboveLet"), - Core.fieldTerm = (liftLambdaAboveLetTestCase v0)}}) - Testing.TestCaseSerialization v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "serialization"), - Core.fieldTerm = (serializationTestCase v0)}}) - Testing.TestCaseSimplifyTerm v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "simplifyTerm"), - Core.fieldTerm = (simplifyTermTestCase v0)}}) - Testing.TestCaseTopologicalSort v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "topologicalSort"), - Core.fieldTerm = (topologicalSortTestCase v0)}}) - Testing.TestCaseTopologicalSortBindings v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "topologicalSortBindings"), - Core.fieldTerm = (topologicalSortBindingsTestCase v0)}}) - Testing.TestCaseTopologicalSortSCC v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "topologicalSortSCC"), - Core.fieldTerm = (topologicalSortSCCTestCase v0)}}) - Testing.TestCaseTypeChecking v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "typeChecking"), - Core.fieldTerm = (typeCheckingTestCase v0)}}) - Testing.TestCaseTypeCheckingFailure v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "typeCheckingFailure"), - Core.fieldTerm = (typeCheckingFailureTestCase v0)}}) - Testing.TestCaseTypeReduction v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "typeReduction"), - Core.fieldTerm = (typeReductionTestCase v0)}}) - Testing.TestCaseNormalizeTypeVariables v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "normalizeTypeVariables"), - Core.fieldTerm = (normalizeTypeVariablesTestCase v0)}}) - Testing.TestCaseFoldOverTerm v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "foldOverTerm"), - Core.fieldTerm = (foldOverTermTestCase v0)}}) - Testing.TestCaseRewriteTerm v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "rewriteTerm"), - Core.fieldTerm = (rewriteTermTestCase v0)}}) - Testing.TestCaseRewriteType v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "rewriteType"), - Core.fieldTerm = (rewriteTypeTestCase v0)}}) - Testing.TestCaseHoistSubterms v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "hoistSubterms"), - Core.fieldTerm = (hoistSubtermsTestCase v0)}}) - Testing.TestCaseHoistCaseStatements v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "hoistCaseStatements"), - Core.fieldTerm = (hoistCaseStatementsTestCase v0)}}) - Testing.TestCaseHoistLetBindings v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "hoistLetBindings"), - Core.fieldTerm = (hoistLetBindingsTestCase v0)}}) - Testing.TestCaseHoistPolymorphicLetBindings v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "hoistPolymorphicLetBindings"), - Core.fieldTerm = (hoistPolymorphicLetBindingsTestCase v0)}}) - Testing.TestCaseSubstInType v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "substInType"), - Core.fieldTerm = (substInTypeTestCase v0)}}) - Testing.TestCaseVariableOccursInType v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "variableOccursInType"), - Core.fieldTerm = (variableOccursInTypeTestCase v0)}}) - Testing.TestCaseUnifyTypes v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unifyTypes"), - Core.fieldTerm = (unifyTypesTestCase v0)}}) - Testing.TestCaseJoinTypes v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "joinTypes"), - Core.fieldTerm = (joinTypesTestCase v0)}}) - Testing.TestCaseUnshadowVariables v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unshadowVariables"), - Core.fieldTerm = (unshadowVariablesTestCase v0)}}) - Testing.TestCaseValidateCoreTerm v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "validateCoreTerm"), - Core.fieldTerm = (validateCoreTermTestCase v0)}}) - -testCaseWithMetadata :: Testing.TestCaseWithMetadata -> Core.Term -testCaseWithMetadata x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = ((\x -> Core.TermLiteral (Core.LiteralString x)) (Testing.testCaseWithMetadataName x))}, - Core.Field { - Core.fieldName = (Core.Name "case"), - Core.fieldTerm = (testCase (Testing.testCaseWithMetadataCase x))}, - Core.Field { - Core.fieldName = (Core.Name "description"), - Core.fieldTerm = ((\opt -> Core.TermMaybe (Maybes.map (\x -> Core.TermLiteral (Core.LiteralString x)) opt)) (Testing.testCaseWithMetadataDescription x))}, - Core.Field { - Core.fieldName = (Core.Name "tags"), - Core.fieldTerm = ((\xs -> Core.TermList (Lists.map tag xs)) (Testing.testCaseWithMetadataTags x))}]}) - -testGroup :: Testing.TestGroup -> Core.Term -testGroup x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.TestGroup"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = ((\x -> Core.TermLiteral (Core.LiteralString x)) (Testing.testGroupName x))}, - Core.Field { - Core.fieldName = (Core.Name "description"), - Core.fieldTerm = ((\opt -> Core.TermMaybe (Maybes.map (\x -> Core.TermLiteral (Core.LiteralString x)) opt)) (Testing.testGroupDescription x))}, - Core.Field { - Core.fieldName = (Core.Name "subgroups"), - Core.fieldTerm = ((\xs -> Core.TermList (Lists.map testGroup xs)) (Testing.testGroupSubgroups x))}, - Core.Field { - Core.fieldName = (Core.Name "cases"), - Core.fieldTerm = ((\xs -> Core.TermList (Lists.map testCaseWithMetadata xs)) (Testing.testGroupCases x))}]}) - -topologicalSortBindingsTestCase :: Testing.TopologicalSortBindingsTestCase -> Core.Term -topologicalSortBindingsTestCase x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.TopologicalSortBindingsTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "bindings"), - Core.fieldTerm = ((\xs -> Core.TermList (Lists.map (\p -> Core.TermPair (Pairs.bimap Core_.name Core_.term p)) xs)) (Testing.topologicalSortBindingsTestCaseBindings x))}, - Core.Field { - Core.fieldName = (Core.Name "expected"), - Core.fieldTerm = ((\xs -> Core.TermList (Lists.map (\xs -> Core.TermList (Lists.map (\p -> Core.TermPair (Pairs.bimap Core_.name Core_.term p)) xs)) xs)) (Testing.topologicalSortBindingsTestCaseExpected x))}]}) - -topologicalSortSCCTestCase :: Testing.TopologicalSortSCCTestCase -> Core.Term -topologicalSortSCCTestCase x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.TopologicalSortSCCTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "adjacencyList"), - Core.fieldTerm = ((\xs -> Core.TermList (Lists.map (\p -> Core.TermPair (Pairs.bimap (\x -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x))) (\xs -> Core.TermList (Lists.map (\x -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x))) xs)) p)) xs)) (Testing.topologicalSortSCCTestCaseAdjacencyList x))}, - Core.Field { - Core.fieldName = (Core.Name "expected"), - Core.fieldTerm = ((\xs -> Core.TermList (Lists.map (\xs -> Core.TermList (Lists.map (\x -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x))) xs)) xs)) (Testing.topologicalSortSCCTestCaseExpected x))}]}) - -topologicalSortTestCase :: Testing.TopologicalSortTestCase -> Core.Term -topologicalSortTestCase x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.TopologicalSortTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "adjacencyList"), - Core.fieldTerm = ((\xs -> Core.TermList (Lists.map (\p -> Core.TermPair (Pairs.bimap (\x -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x))) (\xs -> Core.TermList (Lists.map (\x -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x))) xs)) p)) xs)) (Testing.topologicalSortTestCaseAdjacencyList x))}, - Core.Field { - Core.fieldName = (Core.Name "expected"), - Core.fieldTerm = ((\e -> Core.TermEither (Eithers.bimap (\xs -> Core.TermList (Lists.map (\xs -> Core.TermList (Lists.map (\x -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x))) xs)) xs)) (\xs -> Core.TermList (Lists.map (\x -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x))) xs)) e)) (Testing.topologicalSortTestCaseExpected x))}]}) - -typeCheckingFailureTestCase :: Testing.TypeCheckingFailureTestCase -> Core.Term -typeCheckingFailureTestCase x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.TypeCheckingFailureTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core_.term (Testing.typeCheckingFailureTestCaseInput x))}]}) - -typeCheckingTestCase :: Testing.TypeCheckingTestCase -> Core.Term -typeCheckingTestCase x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.TypeCheckingTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core_.term (Testing.typeCheckingTestCaseInput x))}, - Core.Field { - Core.fieldName = (Core.Name "outputTerm"), - Core.fieldTerm = (Core_.term (Testing.typeCheckingTestCaseOutputTerm x))}, - Core.Field { - Core.fieldName = (Core.Name "outputType"), - Core.fieldTerm = (Core_.type_ (Testing.typeCheckingTestCaseOutputType x))}]}) - -typeReductionTestCase :: Testing.TypeReductionTestCase -> Core.Term -typeReductionTestCase x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.TypeReductionTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core_.type_ (Testing.typeReductionTestCaseInput x))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Core_.type_ (Testing.typeReductionTestCaseOutput x))}]}) - -typeRewriter :: Testing.TypeRewriter -> Core.Term -typeRewriter x = - case x of - Testing.TypeRewriterReplaceStringWithInt32 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.testing.TypeRewriter"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "replaceStringWithInt32"), - Core.fieldTerm = Core.TermUnit}}) - -unifyTypesTestCase :: Testing.UnifyTypesTestCase -> Core.Term -unifyTypesTestCase x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.UnifyTypesTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "schemaTypes"), - Core.fieldTerm = ((\xs -> Core.TermList (Lists.map Core_.name xs)) (Testing.unifyTypesTestCaseSchemaTypes x))}, - Core.Field { - Core.fieldName = (Core.Name "left"), - Core.fieldTerm = (Core_.type_ (Testing.unifyTypesTestCaseLeft x))}, - Core.Field { - Core.fieldName = (Core.Name "right"), - Core.fieldTerm = (Core_.type_ (Testing.unifyTypesTestCaseRight x))}, - Core.Field { - Core.fieldName = (Core.Name "expected"), - Core.fieldTerm = ((\e -> Core.TermEither (Eithers.bimap (\x -> Core.TermLiteral (Core.LiteralString x)) Typing.typeSubst e)) (Testing.unifyTypesTestCaseExpected x))}]}) - -unshadowVariablesTestCase :: Testing.UnshadowVariablesTestCase -> Core.Term -unshadowVariablesTestCase x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.UnshadowVariablesTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core_.term (Testing.unshadowVariablesTestCaseInput x))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = (Core_.term (Testing.unshadowVariablesTestCaseOutput x))}]}) - -validateCoreTermTestCase :: Testing.ValidateCoreTermTestCase -> Core.Term -validateCoreTermTestCase x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.ValidateCoreTermTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typed"), - Core.fieldTerm = ((\x -> Core.TermLiteral (Core.LiteralBoolean x)) (Testing.validateCoreTermTestCaseTyped x))}, - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (Core_.term (Testing.validateCoreTermTestCaseInput x))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = ((\opt -> Core.TermMaybe (Maybes.map Core__.invalidTermError opt)) (Testing.validateCoreTermTestCaseOutput x))}]}) - -variableOccursInTypeTestCase :: Testing.VariableOccursInTypeTestCase -> Core.Term -variableOccursInTypeTestCase x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.VariableOccursInTypeTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "variable"), - Core.fieldTerm = (Core_.name (Testing.variableOccursInTypeTestCaseVariable x))}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core_.type_ (Testing.variableOccursInTypeTestCaseType x))}, - Core.Field { - Core.fieldName = (Core.Name "expected"), - Core.fieldTerm = ((\x -> Core.TermLiteral (Core.LiteralBoolean x)) (Testing.variableOccursInTypeTestCaseExpected x))}]}) - -writerTestCase :: (t0 -> Core.Term) -> Testing.WriterTestCase t0 -> Core.Term -writerTestCase a x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.testing.WriterTestCase"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "input"), - Core.fieldTerm = (a (Testing.writerTestCaseInput x))}, - Core.Field { - Core.fieldName = (Core.Name "output"), - Core.fieldTerm = ((\x -> Core.TermLiteral (Core.LiteralString x)) (Testing.writerTestCaseOutput x))}]}) diff --git a/src/gen-main/haskell/Hydra/Encode/Topology.hs b/src/gen-main/haskell/Hydra/Encode/Topology.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Encode/Topology.hs +++ /dev/null @@ -1,47 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Term encoders for hydra.topology - -module Hydra.Encode.Topology where - -import qualified Hydra.Core as Core -import qualified Hydra.Lib.Lists as Lists -import qualified Hydra.Lib.Maps as Maps -import qualified Hydra.Lib.Sets as Sets -import qualified Hydra.Topology as Topology -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -graph :: M.Map Int [Int] -> Core.Term -graph m = Core.TermMap (Maps.bimap vertex (\xs -> Core.TermList (Lists.map vertex xs)) m) - -tarjanState :: Topology.TarjanState -> Core.Term -tarjanState x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.topology.TarjanState"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "counter"), - Core.fieldTerm = ((\x -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x))) (Topology.tarjanStateCounter x))}, - Core.Field { - Core.fieldName = (Core.Name "indices"), - Core.fieldTerm = ((\m -> Core.TermMap (Maps.bimap vertex (\x -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x))) m)) (Topology.tarjanStateIndices x))}, - Core.Field { - Core.fieldName = (Core.Name "lowLinks"), - Core.fieldTerm = ((\m -> Core.TermMap (Maps.bimap vertex (\x -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x))) m)) (Topology.tarjanStateLowLinks x))}, - Core.Field { - Core.fieldName = (Core.Name "stack"), - Core.fieldTerm = ((\xs -> Core.TermList (Lists.map vertex xs)) (Topology.tarjanStateStack x))}, - Core.Field { - Core.fieldName = (Core.Name "onStack"), - Core.fieldTerm = ((\s -> Core.TermSet (Sets.map vertex s)) (Topology.tarjanStateOnStack x))}, - Core.Field { - Core.fieldName = (Core.Name "sccs"), - Core.fieldTerm = ((\xs -> Core.TermList (Lists.map (\xs -> Core.TermList (Lists.map vertex xs)) xs)) (Topology.tarjanStateSccs x))}]}) - -vertex :: Int -> Core.Term -vertex x = Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x)) diff --git a/src/gen-main/haskell/Hydra/Encode/Typing.hs b/src/gen-main/haskell/Hydra/Encode/Typing.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Encode/Typing.hs +++ /dev/null @@ -1,94 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Term encoders for hydra.typing - -module Hydra.Encode.Typing where - -import qualified Hydra.Core as Core -import qualified Hydra.Encode.Context as Context -import qualified Hydra.Encode.Core as Core_ -import qualified Hydra.Lib.Lists as Lists -import qualified Hydra.Lib.Maps as Maps -import qualified Hydra.Lib.Maybes as Maybes -import qualified Hydra.Typing as Typing -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -functionStructure :: (t0 -> Core.Term) -> Typing.FunctionStructure t0 -> Core.Term -functionStructure env x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.typing.FunctionStructure"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeParams"), - Core.fieldTerm = ((\xs -> Core.TermList (Lists.map Core_.name xs)) (Typing.functionStructureTypeParams x))}, - Core.Field { - Core.fieldName = (Core.Name "params"), - Core.fieldTerm = ((\xs -> Core.TermList (Lists.map Core_.name xs)) (Typing.functionStructureParams x))}, - Core.Field { - Core.fieldName = (Core.Name "bindings"), - Core.fieldTerm = ((\xs -> Core.TermList (Lists.map Core_.binding xs)) (Typing.functionStructureBindings x))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core_.term (Typing.functionStructureBody x))}, - Core.Field { - Core.fieldName = (Core.Name "domains"), - Core.fieldTerm = ((\xs -> Core.TermList (Lists.map Core_.type_ xs)) (Typing.functionStructureDomains x))}, - Core.Field { - Core.fieldName = (Core.Name "codomain"), - Core.fieldTerm = ((\opt -> Core.TermMaybe (Maybes.map Core_.type_ opt)) (Typing.functionStructureCodomain x))}, - Core.Field { - Core.fieldName = (Core.Name "environment"), - Core.fieldTerm = (env (Typing.functionStructureEnvironment x))}]}) - -inferenceResult :: Typing.InferenceResult -> Core.Term -inferenceResult x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.typing.InferenceResult"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core_.term (Typing.inferenceResultTerm x))}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core_.type_ (Typing.inferenceResultType x))}, - Core.Field { - Core.fieldName = (Core.Name "subst"), - Core.fieldTerm = (typeSubst (Typing.inferenceResultSubst x))}, - Core.Field { - Core.fieldName = (Core.Name "classConstraints"), - Core.fieldTerm = ((\m -> Core.TermMap (Maps.bimap Core_.name Core_.typeVariableMetadata m)) (Typing.inferenceResultClassConstraints x))}, - Core.Field { - Core.fieldName = (Core.Name "context"), - Core.fieldTerm = (Context.context (Typing.inferenceResultContext x))}]}) - -termSubst :: Typing.TermSubst -> Core.Term -termSubst x = - Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.typing.TermSubst"), - Core.wrappedTermBody = ((\m -> Core.TermMap (Maps.bimap Core_.name Core_.term m)) (Typing.unTermSubst x))}) - -typeConstraint :: Typing.TypeConstraint -> Core.Term -typeConstraint x = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.typing.TypeConstraint"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "left"), - Core.fieldTerm = (Core_.type_ (Typing.typeConstraintLeft x))}, - Core.Field { - Core.fieldName = (Core.Name "right"), - Core.fieldTerm = (Core_.type_ (Typing.typeConstraintRight x))}, - Core.Field { - Core.fieldName = (Core.Name "comment"), - Core.fieldTerm = ((\x -> Core.TermLiteral (Core.LiteralString x)) (Typing.typeConstraintComment x))}]}) - -typeSubst :: Typing.TypeSubst -> Core.Term -typeSubst x = - Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.typing.TypeSubst"), - Core.wrappedTermBody = ((\m -> Core.TermMap (Maps.bimap Core_.name Core_.type_ m)) (Typing.unTypeSubst x))}) diff --git a/src/gen-main/haskell/Hydra/Encode/Util.hs b/src/gen-main/haskell/Hydra/Encode/Util.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Encode/Util.hs +++ /dev/null @@ -1,71 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Term encoders for hydra.util - -module Hydra.Encode.Util where - -import qualified Hydra.Core as Core -import qualified Hydra.Util as Util -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -caseConvention :: Util.CaseConvention -> Core.Term -caseConvention x = - case x of - Util.CaseConventionCamel -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.util.CaseConvention"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "camel"), - Core.fieldTerm = Core.TermUnit}}) - Util.CaseConventionPascal -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.util.CaseConvention"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "pascal"), - Core.fieldTerm = Core.TermUnit}}) - Util.CaseConventionLowerSnake -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.util.CaseConvention"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "lowerSnake"), - Core.fieldTerm = Core.TermUnit}}) - Util.CaseConventionUpperSnake -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.util.CaseConvention"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "upperSnake"), - Core.fieldTerm = Core.TermUnit}}) - -comparison :: Util.Comparison -> Core.Term -comparison x = - case x of - Util.ComparisonLessThan -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.util.Comparison"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "lessThan"), - Core.fieldTerm = Core.TermUnit}}) - Util.ComparisonEqualTo -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.util.Comparison"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "equalTo"), - Core.fieldTerm = Core.TermUnit}}) - Util.ComparisonGreaterThan -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.util.Comparison"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "greaterThan"), - Core.fieldTerm = Core.TermUnit}}) - -precision :: Util.Precision -> Core.Term -precision x = - case x of - Util.PrecisionArbitrary -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.util.Precision"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "arbitrary"), - Core.fieldTerm = Core.TermUnit}}) - Util.PrecisionBits v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.util.Precision"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "bits"), - Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 v0)))}}) diff --git a/src/gen-main/haskell/Hydra/Encode/Variants.hs b/src/gen-main/haskell/Hydra/Encode/Variants.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Encode/Variants.hs +++ /dev/null @@ -1,264 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Term encoders for hydra.variants - -module Hydra.Encode.Variants where - -import qualified Hydra.Core as Core -import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -eliminationVariant :: Variants.EliminationVariant -> Core.Term -eliminationVariant x = - case x of - Variants.EliminationVariantRecord -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.EliminationVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = Core.TermUnit}}) - Variants.EliminationVariantUnion -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.EliminationVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "union"), - Core.fieldTerm = Core.TermUnit}}) - Variants.EliminationVariantWrap -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.EliminationVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wrap"), - Core.fieldTerm = Core.TermUnit}}) - -functionVariant :: Variants.FunctionVariant -> Core.Term -functionVariant x = - case x of - Variants.FunctionVariantElimination -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.FunctionVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "elimination"), - Core.fieldTerm = Core.TermUnit}}) - Variants.FunctionVariantLambda -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.FunctionVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "lambda"), - Core.fieldTerm = Core.TermUnit}}) - Variants.FunctionVariantPrimitive -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.FunctionVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "primitive"), - Core.fieldTerm = Core.TermUnit}}) - -literalVariant :: Variants.LiteralVariant -> Core.Term -literalVariant x = - case x of - Variants.LiteralVariantBinary -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.LiteralVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "binary"), - Core.fieldTerm = Core.TermUnit}}) - Variants.LiteralVariantBoolean -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.LiteralVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "boolean"), - Core.fieldTerm = Core.TermUnit}}) - Variants.LiteralVariantFloat -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.LiteralVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "float"), - Core.fieldTerm = Core.TermUnit}}) - Variants.LiteralVariantInteger -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.LiteralVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = Core.TermUnit}}) - Variants.LiteralVariantString -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.LiteralVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = Core.TermUnit}}) - -termVariant :: Variants.TermVariant -> Core.Term -termVariant x = - case x of - Variants.TermVariantAnnotated -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "annotated"), - Core.fieldTerm = Core.TermUnit}}) - Variants.TermVariantApplication -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "application"), - Core.fieldTerm = Core.TermUnit}}) - Variants.TermVariantEither -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "either"), - Core.fieldTerm = Core.TermUnit}}) - Variants.TermVariantFunction -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "function"), - Core.fieldTerm = Core.TermUnit}}) - Variants.TermVariantLet -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "let"), - Core.fieldTerm = Core.TermUnit}}) - Variants.TermVariantList -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = Core.TermUnit}}) - Variants.TermVariantLiteral -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = Core.TermUnit}}) - Variants.TermVariantMap -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "map"), - Core.fieldTerm = Core.TermUnit}}) - Variants.TermVariantMaybe -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "maybe"), - Core.fieldTerm = Core.TermUnit}}) - Variants.TermVariantPair -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "pair"), - Core.fieldTerm = Core.TermUnit}}) - Variants.TermVariantRecord -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = Core.TermUnit}}) - Variants.TermVariantSet -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "set"), - Core.fieldTerm = Core.TermUnit}}) - Variants.TermVariantTypeApplication -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "typeApplication"), - Core.fieldTerm = Core.TermUnit}}) - Variants.TermVariantTypeLambda -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "typeLambda"), - Core.fieldTerm = Core.TermUnit}}) - Variants.TermVariantUnion -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "union"), - Core.fieldTerm = Core.TermUnit}}) - Variants.TermVariantUnit -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}) - Variants.TermVariantVariable -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "variable"), - Core.fieldTerm = Core.TermUnit}}) - Variants.TermVariantWrap -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wrap"), - Core.fieldTerm = Core.TermUnit}}) - -typeVariant :: Variants.TypeVariant -> Core.Term -typeVariant x = - case x of - Variants.TypeVariantAnnotated -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "annotated"), - Core.fieldTerm = Core.TermUnit}}) - Variants.TypeVariantApplication -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "application"), - Core.fieldTerm = Core.TermUnit}}) - Variants.TypeVariantEither -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "either"), - Core.fieldTerm = Core.TermUnit}}) - Variants.TypeVariantForall -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "forall"), - Core.fieldTerm = Core.TermUnit}}) - Variants.TypeVariantFunction -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "function"), - Core.fieldTerm = Core.TermUnit}}) - Variants.TypeVariantList -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = Core.TermUnit}}) - Variants.TypeVariantLiteral -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = Core.TermUnit}}) - Variants.TypeVariantMap -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "map"), - Core.fieldTerm = Core.TermUnit}}) - Variants.TypeVariantMaybe -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "maybe"), - Core.fieldTerm = Core.TermUnit}}) - Variants.TypeVariantPair -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "pair"), - Core.fieldTerm = Core.TermUnit}}) - Variants.TypeVariantRecord -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = Core.TermUnit}}) - Variants.TypeVariantSet -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "set"), - Core.fieldTerm = Core.TermUnit}}) - Variants.TypeVariantUnion -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "union"), - Core.fieldTerm = Core.TermUnit}}) - Variants.TypeVariantUnit -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}) - Variants.TypeVariantVariable -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "variable"), - Core.fieldTerm = Core.TermUnit}}) - Variants.TypeVariantVoid -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "void"), - Core.fieldTerm = Core.TermUnit}}) - Variants.TypeVariantWrap -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wrap"), - Core.fieldTerm = Core.TermUnit}}) diff --git a/src/gen-main/haskell/Hydra/Encoding.hs b/src/gen-main/haskell/Hydra/Encoding.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Encoding.hs +++ /dev/null @@ -1,693 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Functions for generating term encoders from type modules - -module Hydra.Encoding where - -import qualified Hydra.Annotations as Annotations -import qualified Hydra.Context as Context -import qualified Hydra.Core as Core -import qualified Hydra.Decode.Core as Core_ -import qualified Hydra.Errors as Errors -import qualified Hydra.Formatting as Formatting -import qualified Hydra.Graph as Graph -import qualified Hydra.Lib.Eithers as Eithers -import qualified Hydra.Lib.Lists as Lists -import qualified Hydra.Lib.Logic as Logic -import qualified Hydra.Lib.Maps as Maps -import qualified Hydra.Lib.Maybes as Maybes -import qualified Hydra.Lib.Sets as Sets -import qualified Hydra.Lib.Strings as Strings -import qualified Hydra.Module as Module -import qualified Hydra.Names as Names -import qualified Hydra.Schemas as Schemas -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | Transform a type binding into an encoder binding -encodeBinding :: Context.Context -> Graph.Graph -> Core.Binding -> Either (Context.InContext Errors.DecodingError) Core.Binding -encodeBinding cx graph b = - Eithers.bind (Eithers.bimap (\_wc_e -> Context.InContext { - Context.inContextObject = _wc_e, - Context.inContextContext = cx}) (\_wc_a -> _wc_a) (Core_.type_ graph (Core.bindingTerm b))) (\typ -> Right (Core.Binding { - Core.bindingName = (encodeBindingName (Core.bindingName b)), - Core.bindingTerm = (encodeTypeNamed (Core.bindingName b) typ), - Core.bindingType = (Just (encoderTypeSchemeNamed (Core.bindingName b) typ))})) - --- | Generate a binding name for an encoder function from a type name -encodeBindingName :: Core.Name -> Core.Name -encodeBindingName n = - Logic.ifElse (Logic.not (Lists.null (Lists.tail (Strings.splitOn "." (Core.unName n))))) (Core.Name (Strings.intercalate "." (Lists.concat2 [ - "hydra", - "encode"] (Lists.concat2 (Lists.tail (Lists.init (Strings.splitOn "." (Core.unName n)))) [ - Formatting.decapitalize (Names.localNameOf n)])))) (Core.Name (Formatting.decapitalize (Names.localNameOf n))) - --- | Generate an encoder for an Either type -encodeEitherType :: Core.EitherType -> Core.Term -encodeEitherType et = - Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "e"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "either"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bimap"))), - Core.applicationArgument = (encodeType (Core.eitherTypeLeft et))})), - Core.applicationArgument = (encodeType (Core.eitherTypeRight et))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "e"))}))}}))})) - --- | Generate the encoder for a field's value -encodeFieldValue :: Core.Name -> Core.Name -> Core.Type -> Core.Term -encodeFieldValue typeName fieldName fieldType = - Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "union"), - Core.fieldTerm = (encodeInjection typeName fieldName (Core.TermApplication (Core.Application { - Core.applicationFunction = (encodeType fieldType), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))})))}}))})) - --- | Encode a float value based on its float type -encodeFloatValue :: Core.FloatType -> Core.Term -> Core.Term -encodeFloatValue floatType valTerm = - Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.FloatValue"), - Core.injectionField = Core.Field { - Core.fieldName = case floatType of - Core.FloatTypeBigfloat -> Core.Name "bigfloat" - Core.FloatTypeFloat32 -> Core.Name "float32" - Core.FloatTypeFloat64 -> Core.Name "float64", - Core.fieldTerm = valTerm}}) - --- | Generate an encoder for a polymorphic (forall) type -encodeForallType :: Core.ForallType -> Core.Term -encodeForallType ft = - Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (encodeBindingName (Core.forallTypeParameter ft)), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (encodeType (Core.forallTypeBody ft))})) - --- | Encode an Injection as a term -encodeInjection :: Core.Name -> Core.Name -> Core.Term -> Core.Term -encodeInjection typeName fieldName fieldTerm = - Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (encodeName typeName)}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = ((\fname -> \fterm -> Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (encodeName fname)}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = fterm}]})) fieldName fieldTerm)}]}) - --- | Encode an integer value based on its integer type -encodeIntegerValue :: Core.IntegerType -> Core.Term -> Core.Term -encodeIntegerValue intType valTerm = - Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = case intType of - Core.IntegerTypeBigint -> Core.Name "bigint" - Core.IntegerTypeInt8 -> Core.Name "int8" - Core.IntegerTypeInt16 -> Core.Name "int16" - Core.IntegerTypeInt32 -> Core.Name "int32" - Core.IntegerTypeInt64 -> Core.Name "int64" - Core.IntegerTypeUint8 -> Core.Name "uint8" - Core.IntegerTypeUint16 -> Core.Name "uint16" - Core.IntegerTypeUint32 -> Core.Name "uint32" - Core.IntegerTypeUint64 -> Core.Name "uint64", - Core.fieldTerm = valTerm}}) - --- | Generate an encoder for a list type -encodeListType :: Core.Type -> Core.Term -encodeListType elemType = - Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "xs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.lists.map"))), - Core.applicationArgument = (encodeType elemType)})), - Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})) - --- | Generate an encoder for a literal type -encodeLiteralType :: Core.LiteralType -> Core.Term -encodeLiteralType x = - case x of - Core.LiteralTypeBinary -> Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "binary"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})) - Core.LiteralTypeBoolean -> Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "boolean"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})) - Core.LiteralTypeString -> Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})) - Core.LiteralTypeInteger v0 -> Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (encodeIntegerValue v0 (Core.TermVariable (Core.Name "x")))}}))}}))})) - Core.LiteralTypeFloat v0 -> Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "float"), - Core.fieldTerm = (encodeFloatValue v0 (Core.TermVariable (Core.Name "x")))}}))}}))})) - _ -> Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermVariable (Core.Name "x"))})) - --- | Generate an encoder for a map type -encodeMapType :: Core.MapType -> Core.Term -encodeMapType mt = - Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "m"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "map"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.bimap"))), - Core.applicationArgument = (encodeType (Core.mapTypeKeys mt))})), - Core.applicationArgument = (encodeType (Core.mapTypeValues mt))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "m"))}))}}))})) - --- | Transform a type module into an encoder module -encodeModule :: Context.Context -> Graph.Graph -> Module.Module -> Either (Context.InContext Errors.Error) (Maybe Module.Module) -encodeModule cx graph mod = - Eithers.bind (filterTypeBindings cx graph (Maybes.cat (Lists.map (\d -> case d of - Module.DefinitionType v0 -> Just (Annotations.typeElement (Module.typeDefinitionName v0) (Module.typeDefinitionType v0)) - _ -> Nothing) (Module.moduleDefinitions mod)))) (\typeBindings -> Logic.ifElse (Lists.null typeBindings) (Right Nothing) (Eithers.bind (Eithers.mapList (\b -> Eithers.bimap (\ic -> Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Errors.unDecodingError (Context.inContextObject ic)))), - Context.inContextContext = (Context.inContextContext ic)}) (\x -> x) (encodeBinding cx graph b)) typeBindings) (\encodedBindings -> Right (Just (Module.Module { - Module.moduleNamespace = (encodeNamespace (Module.moduleNamespace mod)), - Module.moduleDefinitions = (Lists.map (\b -> Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.bindingName b), - Module.termDefinitionTerm = (Core.bindingTerm b), - Module.termDefinitionType = (Core.bindingType b)})) encodedBindings), - Module.moduleTermDependencies = (Lists.nub (Lists.concat2 (Lists.map encodeNamespace (Module.moduleTypeDependencies mod)) (Lists.map encodeNamespace (Module.moduleTermDependencies mod)))), - Module.moduleTypeDependencies = [ - Module.moduleNamespace mod], - Module.moduleDescription = (Just (Strings.cat [ - "Term encoders for ", - (Module.unNamespace (Module.moduleNamespace mod))]))}))))) - --- | Encode a Name as a term -encodeName :: Core.Name -> Core.Term -encodeName n = - Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Core.unName n)))}) - --- | Generate an encoder module namespace from a source module namespace -encodeNamespace :: Module.Namespace -> Module.Namespace -encodeNamespace ns = - Module.Namespace (Strings.cat [ - "hydra.encode.", - (Strings.intercalate "." (Lists.tail (Strings.splitOn "." (Module.unNamespace ns))))]) - --- | Generate an encoder for an optional type -encodeOptionalType :: Core.Type -> Core.Term -encodeOptionalType elemType = - Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "opt"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "maybe"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maybes.map"))), - Core.applicationArgument = (encodeType elemType)})), - Core.applicationArgument = (Core.TermVariable (Core.Name "opt"))}))}}))})) - --- | Generate an encoder for a pair type -encodePairType :: Core.PairType -> Core.Term -encodePairType pt = - Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "p"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "pair"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.pairs.bimap"))), - Core.applicationArgument = (encodeType (Core.pairTypeFirst pt))})), - Core.applicationArgument = (encodeType (Core.pairTypeSecond pt))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "p"))}))}}))})) - --- | Generate an encoder for a record type (unnamed — should not be called directly) -encodeRecordType :: [Core.FieldType] -> Core.Term -encodeRecordType rt = encodeRecordTypeNamed (Core.Name "unknown") rt - --- | Generate an encoder for a record type with the given element name -encodeRecordTypeNamed :: Core.Name -> [Core.FieldType] -> Core.Term -encodeRecordTypeNamed ename rt = - Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (encodeName ename)}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermList (Lists.map ((\tname -> \recType -> \ft -> Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (encodeName (Core.fieldTypeName ft))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (encodeType (Core.fieldTypeType ft)), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = tname, - Core.projectionField = (Core.fieldTypeName ft)})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})) ename rt) rt))}]}))}}))})) - --- | Generate an encoder for a set type -encodeSetType :: Core.Type -> Core.Term -encodeSetType elemType = - Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "s"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "set"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.sets.map"))), - Core.applicationArgument = (encodeType elemType)})), - Core.applicationArgument = (Core.TermVariable (Core.Name "s"))}))}}))})) - --- | Generate an encoder term for a Type -encodeType :: Core.Type -> Core.Term -encodeType x = - case x of - Core.TypeAnnotated v0 -> encodeType (Core.annotatedTypeBody v0) - Core.TypeApplication v0 -> Core.TermApplication (Core.Application { - Core.applicationFunction = (encodeType (Core.applicationTypeFunction v0)), - Core.applicationArgument = (encodeType (Core.applicationTypeArgument v0))}) - Core.TypeEither v0 -> encodeEitherType v0 - Core.TypeForall v0 -> encodeForallType v0 - Core.TypeFunction _ -> Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermVariable (Core.Name "x"))})) - Core.TypeList v0 -> encodeListType v0 - Core.TypeLiteral v0 -> encodeLiteralType v0 - Core.TypeMap v0 -> encodeMapType v0 - Core.TypeMaybe v0 -> encodeOptionalType v0 - Core.TypePair v0 -> encodePairType v0 - Core.TypeRecord v0 -> encodeRecordType v0 - Core.TypeSet v0 -> encodeSetType v0 - Core.TypeUnion v0 -> encodeUnionType v0 - Core.TypeWrap v0 -> encodeWrappedType v0 - Core.TypeUnit -> Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})) - Core.TypeVoid -> Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})) - Core.TypeVariable v0 -> Core.TermVariable (encodeBindingName v0) - _ -> Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermVariable (Core.Name "x"))})) - --- | Generate an encoder term for a Type, with the element name for nominal types -encodeTypeNamed :: Core.Name -> Core.Type -> Core.Term -encodeTypeNamed ename typ = - case typ of - Core.TypeAnnotated v0 -> encodeTypeNamed ename (Core.annotatedTypeBody v0) - Core.TypeApplication v0 -> Core.TermApplication (Core.Application { - Core.applicationFunction = (encodeType (Core.applicationTypeFunction v0)), - Core.applicationArgument = (encodeType (Core.applicationTypeArgument v0))}) - Core.TypeEither v0 -> encodeEitherType v0 - Core.TypeForall v0 -> Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (encodeBindingName (Core.forallTypeParameter v0)), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (encodeTypeNamed ename (Core.forallTypeBody v0))})) - Core.TypeFunction _ -> Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermVariable (Core.Name "x"))})) - Core.TypeList v0 -> encodeListType v0 - Core.TypeLiteral v0 -> encodeLiteralType v0 - Core.TypeMap v0 -> encodeMapType v0 - Core.TypeMaybe v0 -> encodeOptionalType v0 - Core.TypePair v0 -> encodePairType v0 - Core.TypeRecord v0 -> encodeRecordTypeNamed ename v0 - Core.TypeSet v0 -> encodeSetType v0 - Core.TypeUnion v0 -> encodeUnionTypeNamed ename v0 - Core.TypeWrap v0 -> encodeWrappedTypeNamed ename v0 - Core.TypeUnit -> Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})) - Core.TypeVoid -> Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = Core.TermUnit}}))})) - Core.TypeVariable v0 -> Core.TermVariable (encodeBindingName v0) - _ -> Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermVariable (Core.Name "x"))})) - --- | Generate an encoder for a union type (placeholder name) -encodeUnionType :: [Core.FieldType] -> Core.Term -encodeUnionType rt = encodeUnionTypeNamed (Core.Name "unknown") rt - --- | Generate an encoder for a union type with the given element name -encodeUnionTypeNamed :: Core.Name -> [Core.FieldType] -> Core.Term -encodeUnionTypeNamed ename rt = - Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = ename, - Core.caseStatementDefault = Nothing, - Core.caseStatementCases = (Lists.map (\ft -> Core.Field { - Core.fieldName = (Core.fieldTypeName ft), - Core.fieldTerm = (encodeFieldValue ename (Core.fieldTypeName ft) (Core.fieldTypeType ft))}) rt)}))) - --- | Generate an encoder for a wrapped type (placeholder name) -encodeWrappedType :: Core.Type -> Core.Term -encodeWrappedType wt = encodeWrappedTypeNamed (Core.Name "unknown") wt - --- | Generate an encoder for a wrapped type with the given element name -encodeWrappedTypeNamed :: Core.Name -> Core.Type -> Core.Term -encodeWrappedTypeNamed ename wt = - Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wrap"), - Core.fieldTerm = (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (encodeName ename)}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (encodeType wt), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap ename))), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))}}))})) - --- | Collect forall type variable names from a type -encoderCollectForallVariables :: Core.Type -> [Core.Name] -encoderCollectForallVariables typ = - case typ of - Core.TypeAnnotated v0 -> encoderCollectForallVariables (Core.annotatedTypeBody v0) - Core.TypeForall v0 -> Lists.cons (Core.forallTypeParameter v0) (encoderCollectForallVariables (Core.forallTypeBody v0)) - _ -> [] - --- | Collect type variables needing Ord constraints -encoderCollectOrdVars :: Core.Type -> [Core.Name] -encoderCollectOrdVars typ = - case typ of - Core.TypeAnnotated v0 -> encoderCollectOrdVars (Core.annotatedTypeBody v0) - Core.TypeApplication v0 -> Lists.concat2 (encoderCollectOrdVars (Core.applicationTypeFunction v0)) (encoderCollectOrdVars (Core.applicationTypeArgument v0)) - Core.TypeEither v0 -> Lists.concat2 (encoderCollectOrdVars (Core.eitherTypeLeft v0)) (encoderCollectOrdVars (Core.eitherTypeRight v0)) - Core.TypeForall v0 -> encoderCollectOrdVars (Core.forallTypeBody v0) - Core.TypeList v0 -> encoderCollectOrdVars v0 - Core.TypeMap v0 -> Lists.concat [ - encoderCollectTypeVarsFromType (Core.mapTypeKeys v0), - (encoderCollectOrdVars (Core.mapTypeKeys v0)), - (encoderCollectOrdVars (Core.mapTypeValues v0))] - Core.TypeMaybe v0 -> encoderCollectOrdVars v0 - Core.TypePair v0 -> Lists.concat2 (encoderCollectOrdVars (Core.pairTypeFirst v0)) (encoderCollectOrdVars (Core.pairTypeSecond v0)) - Core.TypeRecord v0 -> Lists.concat (Lists.map (\ft -> encoderCollectOrdVars (Core.fieldTypeType ft)) v0) - Core.TypeSet v0 -> Lists.concat2 (encoderCollectTypeVarsFromType v0) (encoderCollectOrdVars v0) - Core.TypeUnion v0 -> Lists.concat (Lists.map (\ft -> encoderCollectOrdVars (Core.fieldTypeType ft)) v0) - Core.TypeWrap v0 -> encoderCollectOrdVars v0 - _ -> [] - --- | Collect all type variable names from a type expression -encoderCollectTypeVarsFromType :: Core.Type -> [Core.Name] -encoderCollectTypeVarsFromType typ = - case typ of - Core.TypeAnnotated v0 -> encoderCollectTypeVarsFromType (Core.annotatedTypeBody v0) - Core.TypeApplication v0 -> Lists.concat2 (encoderCollectTypeVarsFromType (Core.applicationTypeFunction v0)) (encoderCollectTypeVarsFromType (Core.applicationTypeArgument v0)) - Core.TypeForall v0 -> encoderCollectTypeVarsFromType (Core.forallTypeBody v0) - Core.TypeList v0 -> encoderCollectTypeVarsFromType v0 - Core.TypeMap v0 -> Lists.concat2 (encoderCollectTypeVarsFromType (Core.mapTypeKeys v0)) (encoderCollectTypeVarsFromType (Core.mapTypeValues v0)) - Core.TypeMaybe v0 -> encoderCollectTypeVarsFromType v0 - Core.TypePair v0 -> Lists.concat2 (encoderCollectTypeVarsFromType (Core.pairTypeFirst v0)) (encoderCollectTypeVarsFromType (Core.pairTypeSecond v0)) - Core.TypeRecord v0 -> Lists.concat (Lists.map (\ft -> encoderCollectTypeVarsFromType (Core.fieldTypeType ft)) v0) - Core.TypeSet v0 -> encoderCollectTypeVarsFromType v0 - Core.TypeUnion v0 -> Lists.concat (Lists.map (\ft -> encoderCollectTypeVarsFromType (Core.fieldTypeType ft)) v0) - Core.TypeVariable v0 -> [ - v0] - Core.TypeWrap v0 -> encoderCollectTypeVarsFromType v0 - _ -> [] - --- | Get full result type for encoder input -encoderFullResultType :: Core.Type -> Core.Type -encoderFullResultType typ = - case typ of - Core.TypeAnnotated v0 -> encoderFullResultType (Core.annotatedTypeBody v0) - Core.TypeApplication v0 -> Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (encoderFullResultType (Core.applicationTypeFunction v0)), - Core.applicationTypeArgument = (Core.applicationTypeArgument v0)}) - Core.TypeEither v0 -> Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (encoderFullResultType (Core.eitherTypeLeft v0)), - Core.eitherTypeRight = (encoderFullResultType (Core.eitherTypeRight v0))}) - Core.TypeForall v0 -> Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (encoderFullResultType (Core.forallTypeBody v0)), - Core.applicationTypeArgument = (Core.TypeVariable (Core.forallTypeParameter v0))}) - Core.TypeList v0 -> Core.TypeList (encoderFullResultType v0) - Core.TypeLiteral _ -> Core.TypeVariable (Core.Name "hydra.core.Literal") - Core.TypeMap v0 -> Core.TypeMap (Core.MapType { - Core.mapTypeKeys = (encoderFullResultType (Core.mapTypeKeys v0)), - Core.mapTypeValues = (encoderFullResultType (Core.mapTypeValues v0))}) - Core.TypeMaybe v0 -> Core.TypeMaybe (encoderFullResultType v0) - Core.TypePair v0 -> Core.TypePair (Core.PairType { - Core.pairTypeFirst = (encoderFullResultType (Core.pairTypeFirst v0)), - Core.pairTypeSecond = (encoderFullResultType (Core.pairTypeSecond v0))}) - Core.TypeRecord _ -> Core.TypeVariable (Core.Name "hydra.core.Term") - Core.TypeSet v0 -> Core.TypeSet (encoderFullResultType v0) - Core.TypeUnion _ -> Core.TypeVariable (Core.Name "hydra.core.Term") - Core.TypeUnit -> Core.TypeUnit - Core.TypeVariable v0 -> Core.TypeVariable v0 - Core.TypeVoid -> Core.TypeVoid - Core.TypeWrap _ -> Core.TypeVariable (Core.Name "hydra.core.Term") - _ -> Core.TypeVariable (Core.Name "hydra.core.Term") - --- | Get full result type for encoder input, using element name for nominal types -encoderFullResultTypeNamed :: Core.Name -> Core.Type -> Core.Type -encoderFullResultTypeNamed ename typ = - case typ of - Core.TypeAnnotated v0 -> encoderFullResultTypeNamed ename (Core.annotatedTypeBody v0) - Core.TypeApplication v0 -> Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (encoderFullResultType (Core.applicationTypeFunction v0)), - Core.applicationTypeArgument = (Core.applicationTypeArgument v0)}) - Core.TypeEither v0 -> Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (encoderFullResultType (Core.eitherTypeLeft v0)), - Core.eitherTypeRight = (encoderFullResultType (Core.eitherTypeRight v0))}) - Core.TypeForall v0 -> Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (encoderFullResultTypeNamed ename (Core.forallTypeBody v0)), - Core.applicationTypeArgument = (Core.TypeVariable (Core.forallTypeParameter v0))}) - Core.TypeList v0 -> Core.TypeList (encoderFullResultType v0) - Core.TypeLiteral _ -> Core.TypeVariable (Core.Name "hydra.core.Literal") - Core.TypeMap v0 -> Core.TypeMap (Core.MapType { - Core.mapTypeKeys = (encoderFullResultType (Core.mapTypeKeys v0)), - Core.mapTypeValues = (encoderFullResultType (Core.mapTypeValues v0))}) - Core.TypeMaybe v0 -> Core.TypeMaybe (encoderFullResultType v0) - Core.TypePair v0 -> Core.TypePair (Core.PairType { - Core.pairTypeFirst = (encoderFullResultType (Core.pairTypeFirst v0)), - Core.pairTypeSecond = (encoderFullResultType (Core.pairTypeSecond v0))}) - Core.TypeRecord _ -> Core.TypeVariable ename - Core.TypeSet v0 -> Core.TypeSet (encoderFullResultType v0) - Core.TypeUnion _ -> Core.TypeVariable ename - Core.TypeUnit -> Core.TypeUnit - Core.TypeVariable v0 -> Core.TypeVariable v0 - Core.TypeVoid -> Core.TypeVoid - Core.TypeWrap _ -> Core.TypeVariable ename - _ -> Core.TypeVariable (Core.Name "hydra.core.Term") - --- | Build encoder function type -encoderType :: Core.Type -> Core.Type -encoderType typ = - - let resultType = encoderFullResultType typ - baseType = - Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = resultType, - Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "hydra.core.Term"))}) - in (prependForallEncoders baseType typ) - --- | Build encoder function type with element name for nominal types -encoderTypeNamed :: Core.Name -> Core.Type -> Core.Type -encoderTypeNamed ename typ = - - let resultType = encoderFullResultTypeNamed ename typ - baseType = - Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = resultType, - Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "hydra.core.Term"))}) - in (prependForallEncoders baseType typ) - --- | Construct a TypeScheme for an encoder function from a source type -encoderTypeScheme :: Core.Type -> Core.TypeScheme -encoderTypeScheme typ = - - let typeVars = encoderCollectForallVariables typ - encoderFunType = encoderType typ - allOrdVars = encoderCollectOrdVars typ - ordVars = Lists.filter (\v -> Lists.elem v typeVars) allOrdVars - constraints = - Logic.ifElse (Lists.null ordVars) Nothing (Just (Maps.fromList (Lists.map (\v -> (v, Core.TypeVariableMetadata { - Core.typeVariableMetadataClasses = (Sets.singleton (Core.Name "ordering"))})) ordVars))) - in Core.TypeScheme { - Core.typeSchemeVariables = typeVars, - Core.typeSchemeType = encoderFunType, - Core.typeSchemeConstraints = constraints} - --- | Construct a TypeScheme for an encoder function, with element name for nominal types -encoderTypeSchemeNamed :: Core.Name -> Core.Type -> Core.TypeScheme -encoderTypeSchemeNamed ename typ = - - let typeVars = encoderCollectForallVariables typ - encoderFunType = encoderTypeNamed ename typ - allOrdVars = encoderCollectOrdVars typ - ordVars = Lists.filter (\v -> Lists.elem v typeVars) allOrdVars - constraints = - Logic.ifElse (Lists.null ordVars) Nothing (Just (Maps.fromList (Lists.map (\v -> (v, Core.TypeVariableMetadata { - Core.typeVariableMetadataClasses = (Sets.singleton (Core.Name "ordering"))})) ordVars))) - in Core.TypeScheme { - Core.typeSchemeVariables = typeVars, - Core.typeSchemeType = encoderFunType, - Core.typeSchemeConstraints = constraints} - --- | Filter bindings to only encodable type definitions -filterTypeBindings :: Context.Context -> Graph.Graph -> [Core.Binding] -> Either (Context.InContext Errors.Error) [Core.Binding] -filterTypeBindings cx graph bindings = - Eithers.map Maybes.cat (Eithers.mapList (isEncodableBinding cx graph) (Lists.filter Annotations.isNativeType bindings)) - --- | Check if a binding is encodable (serializable type) -isEncodableBinding :: Context.Context -> Graph.Graph -> Core.Binding -> Either (Context.InContext Errors.Error) (Maybe Core.Binding) -isEncodableBinding cx graph b = - Eithers.bind (Schemas.isSerializableByName cx graph (Core.bindingName b)) (\serializable -> Right (Logic.ifElse serializable (Just b) Nothing)) - --- | Check whether a type is the unit type -isUnitType :: Core.Type -> Bool -isUnitType x = - case x of - Core.TypeUnit -> True - _ -> False - --- | Prepend encoder types for forall parameters to base type -prependForallEncoders :: Core.Type -> Core.Type -> Core.Type -prependForallEncoders baseType typ = - case typ of - Core.TypeAnnotated v0 -> prependForallEncoders baseType (Core.annotatedTypeBody v0) - Core.TypeForall v0 -> Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.forallTypeParameter v0)), - Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "hydra.core.Term"))})), - Core.functionTypeCodomain = (prependForallEncoders baseType (Core.forallTypeBody v0))}) - _ -> baseType diff --git a/src/gen-main/haskell/Hydra/Error/Checking.hs b/src/gen-main/haskell/Hydra/Error/Checking.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Error/Checking.hs +++ /dev/null @@ -1,195 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Error types for type checking - -module Hydra.Error.Checking where - -import qualified Hydra.Core as Core -import qualified Hydra.Typing as Typing -import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | An error that occurred during type checking -data CheckingError = - -- | A post-unification consistency check failure - CheckingErrorIncorrectUnification IncorrectUnificationError | - -- | A type that is not a forall type when one was expected - CheckingErrorNotAForallType NotAForallTypeError | - -- | A type that is not a function type when one was expected - CheckingErrorNotAFunctionType NotAFunctionTypeError | - -- | A type constructor applied to the wrong number of arguments - CheckingErrorTypeArityMismatch TypeArityMismatchError | - -- | A type mismatch between expected and actual types - CheckingErrorTypeMismatch TypeMismatchError | - -- | Type variables that are not bound in scope - CheckingErrorUnboundTypeVariables UnboundTypeVariablesError | - -- | Multiple types that should be equal but are not - CheckingErrorUnequalTypes UnequalTypesError | - -- | A term variant that the type checker does not support - CheckingErrorUnsupportedTermVariant UnsupportedTermVariantError | - -- | A lambda expression without a type annotation on its parameter - CheckingErrorUntypedLambda UntypedLambdaError | - -- | A let binding without a type annotation - CheckingErrorUntypedLetBinding UntypedLetBindingError - deriving (Eq, Ord, Read, Show) - -_CheckingError = Core.Name "hydra.error.checking.CheckingError" - -_CheckingError_incorrectUnification = Core.Name "incorrectUnification" - -_CheckingError_notAForallType = Core.Name "notAForallType" - -_CheckingError_notAFunctionType = Core.Name "notAFunctionType" - -_CheckingError_typeArityMismatch = Core.Name "typeArityMismatch" - -_CheckingError_typeMismatch = Core.Name "typeMismatch" - -_CheckingError_unboundTypeVariables = Core.Name "unboundTypeVariables" - -_CheckingError_unequalTypes = Core.Name "unequalTypes" - -_CheckingError_unsupportedTermVariant = Core.Name "unsupportedTermVariant" - -_CheckingError_untypedLambda = Core.Name "untypedLambda" - -_CheckingError_untypedLetBinding = Core.Name "untypedLetBinding" - --- | A post-unification consistency check failure -data IncorrectUnificationError = - IncorrectUnificationError { - -- | The substitution that failed the consistency check - incorrectUnificationErrorSubstitution :: Typing.TypeSubst} - deriving (Eq, Ord, Read, Show) - -_IncorrectUnificationError = Core.Name "hydra.error.checking.IncorrectUnificationError" - -_IncorrectUnificationError_substitution = Core.Name "substitution" - --- | A type that is not a forall type when type arguments are being applied -data NotAForallTypeError = - NotAForallTypeError { - -- | The actual type encountered - notAForallTypeErrorType :: Core.Type, - -- | The type arguments that were being applied - notAForallTypeErrorTypeArguments :: [Core.Type]} - deriving (Eq, Ord, Read, Show) - -_NotAForallTypeError = Core.Name "hydra.error.checking.NotAForallTypeError" - -_NotAForallTypeError_type = Core.Name "type" - -_NotAForallTypeError_typeArguments = Core.Name "typeArguments" - --- | A type that is not a function type when one was expected in an application -data NotAFunctionTypeError = - NotAFunctionTypeError { - -- | The actual type encountered - notAFunctionTypeErrorType :: Core.Type} - deriving (Eq, Ord, Read, Show) - -_NotAFunctionTypeError = Core.Name "hydra.error.checking.NotAFunctionTypeError" - -_NotAFunctionTypeError_type = Core.Name "type" - --- | A type constructor applied to the wrong number of type arguments -data TypeArityMismatchError = - TypeArityMismatchError { - -- | The type being checked - typeArityMismatchErrorType :: Core.Type, - -- | The expected number of type arguments - typeArityMismatchErrorExpectedArity :: Int, - -- | The actual number of type arguments provided - typeArityMismatchErrorActualArity :: Int, - -- | The type arguments that were provided - typeArityMismatchErrorTypeArguments :: [Core.Type]} - deriving (Eq, Ord, Read, Show) - -_TypeArityMismatchError = Core.Name "hydra.error.checking.TypeArityMismatchError" - -_TypeArityMismatchError_type = Core.Name "type" - -_TypeArityMismatchError_expectedArity = Core.Name "expectedArity" - -_TypeArityMismatchError_actualArity = Core.Name "actualArity" - -_TypeArityMismatchError_typeArguments = Core.Name "typeArguments" - --- | A type mismatch between expected and actual types -data TypeMismatchError = - TypeMismatchError { - -- | The expected type - typeMismatchErrorExpectedType :: Core.Type, - -- | The actual type encountered - typeMismatchErrorActualType :: Core.Type} - deriving (Eq, Ord, Read, Show) - -_TypeMismatchError = Core.Name "hydra.error.checking.TypeMismatchError" - -_TypeMismatchError_expectedType = Core.Name "expectedType" - -_TypeMismatchError_actualType = Core.Name "actualType" - --- | Type variables that appear free in a type but are not bound in scope -data UnboundTypeVariablesError = - UnboundTypeVariablesError { - -- | The set of unbound type variable names - unboundTypeVariablesErrorVariables :: (S.Set Core.Name), - -- | The type containing the unbound variables - unboundTypeVariablesErrorType :: Core.Type} - deriving (Eq, Ord, Read, Show) - -_UnboundTypeVariablesError = Core.Name "hydra.error.checking.UnboundTypeVariablesError" - -_UnboundTypeVariablesError_variables = Core.Name "variables" - -_UnboundTypeVariablesError_type = Core.Name "type" - --- | Multiple types that should all be equal but are not -data UnequalTypesError = - UnequalTypesError { - -- | The list of types that are not all equal - unequalTypesErrorTypes :: [Core.Type], - -- | A description of the context in which the types were expected to be equal - unequalTypesErrorDescription :: String} - deriving (Eq, Ord, Read, Show) - -_UnequalTypesError = Core.Name "hydra.error.checking.UnequalTypesError" - -_UnequalTypesError_types = Core.Name "types" - -_UnequalTypesError_description = Core.Name "description" - --- | A term variant that the type checker does not support -data UnsupportedTermVariantError = - UnsupportedTermVariantError { - -- | The unsupported term variant - unsupportedTermVariantErrorTermVariant :: Variants.TermVariant} - deriving (Eq, Ord, Read, Show) - -_UnsupportedTermVariantError = Core.Name "hydra.error.checking.UnsupportedTermVariantError" - -_UnsupportedTermVariantError_termVariant = Core.Name "termVariant" - --- | A lambda expression without a type annotation on its parameter -data UntypedLambdaError = - UntypedLambdaError {} - deriving (Eq, Ord, Read, Show) - -_UntypedLambdaError = Core.Name "hydra.error.checking.UntypedLambdaError" - --- | A let binding without a type annotation -data UntypedLetBindingError = - UntypedLetBindingError { - -- | The untyped binding - untypedLetBindingErrorBinding :: Core.Binding} - deriving (Eq, Ord, Read, Show) - -_UntypedLetBindingError = Core.Name "hydra.error.checking.UntypedLetBindingError" - -_UntypedLetBindingError_binding = Core.Name "binding" diff --git a/src/gen-main/haskell/Hydra/Error/Core.hs b/src/gen-main/haskell/Hydra/Error/Core.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Error/Core.hs +++ /dev/null @@ -1,716 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Error types for core type and term validation - -module Hydra.Error.Core where - -import qualified Hydra.Core as Core -import qualified Hydra.Paths as Paths -import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | A duplicate binding name in a let expression -data DuplicateBindingError = - DuplicateBindingError { - -- | The path to the duplicate binding within the term - duplicateBindingErrorLocation :: Paths.SubtermPath, - -- | The duplicated binding name - duplicateBindingErrorName :: Core.Name} - deriving (Eq, Ord, Read, Show) - -_DuplicateBindingError = Core.Name "hydra.error.core.DuplicateBindingError" - -_DuplicateBindingError_location = Core.Name "location" - -_DuplicateBindingError_name = Core.Name "name" - --- | A duplicate field name in a record or union type -data DuplicateFieldError = - DuplicateFieldError { - -- | The path to the duplicate field within the term - duplicateFieldErrorLocation :: Paths.SubtermPath, - -- | The duplicated field name - duplicateFieldErrorName :: Core.Name} - deriving (Eq, Ord, Read, Show) - -_DuplicateFieldError = Core.Name "hydra.error.core.DuplicateFieldError" - -_DuplicateFieldError_location = Core.Name "location" - -_DuplicateFieldError_name = Core.Name "name" - --- | A reference to a field that does not exist in the given type -data UndefinedFieldError = - UndefinedFieldError { - -- | The name of the undefined field - undefinedFieldErrorFieldName :: Core.Name, - -- | The name of the type in which the field was expected - undefinedFieldErrorTypeName :: Core.Name} - deriving (Eq, Ord, Read, Show) - -_UndefinedFieldError = Core.Name "hydra.error.core.UndefinedFieldError" - -_UndefinedFieldError_fieldName = Core.Name "fieldName" - -_UndefinedFieldError_typeName = Core.Name "typeName" - --- | An unexpected term variant was encountered -data UnexpectedTermVariantError = - UnexpectedTermVariantError { - -- | The expected term variant - unexpectedTermVariantErrorExpectedVariant :: Variants.TermVariant, - -- | The actual term that was encountered - unexpectedTermVariantErrorActualTerm :: Core.Term} - deriving (Eq, Ord, Read, Show) - -_UnexpectedTermVariantError = Core.Name "hydra.error.core.UnexpectedTermVariantError" - -_UnexpectedTermVariantError_expectedVariant = Core.Name "expectedVariant" - -_UnexpectedTermVariantError_actualTerm = Core.Name "actualTerm" - --- | An unexpected type variant was encountered -data UnexpectedTypeVariantError = - UnexpectedTypeVariantError { - -- | The expected type variant - unexpectedTypeVariantErrorExpectedVariant :: Variants.TypeVariant, - -- | The actual type that was encountered - unexpectedTypeVariantErrorActualType :: Core.Type} - deriving (Eq, Ord, Read, Show) - -_UnexpectedTypeVariantError = Core.Name "hydra.error.core.UnexpectedTypeVariantError" - -_UnexpectedTypeVariantError_expectedVariant = Core.Name "expectedVariant" - -_UnexpectedTypeVariantError_actualType = Core.Name "actualType" - --- | An application of ifElse where the condition is a literal boolean, creating a dead branch (optional) -data ConstantConditionError = - ConstantConditionError { - -- | The path to the constant condition within the term - constantConditionErrorLocation :: Paths.SubtermPath, - -- | The constant boolean value of the condition - constantConditionErrorValue :: Bool} - deriving (Eq, Ord, Read, Show) - -_ConstantConditionError = Core.Name "hydra.error.core.ConstantConditionError" - -_ConstantConditionError_location = Core.Name "location" - -_ConstantConditionError_value = Core.Name "value" - --- | A case statement with no cases and no default (optional) -data EmptyCaseStatementError = - EmptyCaseStatementError { - -- | The path to the empty case statement within the term - emptyCaseStatementErrorLocation :: Paths.SubtermPath, - -- | The name of the union type being matched - emptyCaseStatementErrorTypeName :: Core.Name} - deriving (Eq, Ord, Read, Show) - -_EmptyCaseStatementError = Core.Name "hydra.error.core.EmptyCaseStatementError" - -_EmptyCaseStatementError_location = Core.Name "location" - -_EmptyCaseStatementError_typeName = Core.Name "typeName" - --- | A let expression with an empty list of bindings (optional) -data EmptyLetBindingsError = - EmptyLetBindingsError { - -- | The path to the empty let expression within the term - emptyLetBindingsErrorLocation :: Paths.SubtermPath} - deriving (Eq, Ord, Read, Show) - -_EmptyLetBindingsError = Core.Name "hydra.error.core.EmptyLetBindingsError" - -_EmptyLetBindingsError_location = Core.Name "location" - --- | A term annotation with an empty annotation map (optional) -data EmptyTermAnnotationError = - EmptyTermAnnotationError { - -- | The path to the empty annotation within the term - emptyTermAnnotationErrorLocation :: Paths.SubtermPath} - deriving (Eq, Ord, Read, Show) - -_EmptyTermAnnotationError = Core.Name "hydra.error.core.EmptyTermAnnotationError" - -_EmptyTermAnnotationError_location = Core.Name "location" - --- | A record, injection, projection, or case statement with an empty type name (optional) -data EmptyTypeNameInTermError = - EmptyTypeNameInTermError { - -- | The path to the term with the empty type name - emptyTypeNameInTermErrorLocation :: Paths.SubtermPath} - deriving (Eq, Ord, Read, Show) - -_EmptyTypeNameInTermError = Core.Name "hydra.error.core.EmptyTypeNameInTermError" - -_EmptyTypeNameInTermError_location = Core.Name "location" - --- | A lambda parameter name that violates naming conventions (optional) -data InvalidLambdaParameterNameError = - InvalidLambdaParameterNameError { - -- | The path to the lambda within the term - invalidLambdaParameterNameErrorLocation :: Paths.SubtermPath, - -- | The invalid parameter name - invalidLambdaParameterNameErrorName :: Core.Name} - deriving (Eq, Ord, Read, Show) - -_InvalidLambdaParameterNameError = Core.Name "hydra.error.core.InvalidLambdaParameterNameError" - -_InvalidLambdaParameterNameError_location = Core.Name "location" - -_InvalidLambdaParameterNameError_name = Core.Name "name" - --- | A let binding name that violates naming conventions (optional) -data InvalidLetBindingNameError = - InvalidLetBindingNameError { - -- | The path to the binding within the term - invalidLetBindingNameErrorLocation :: Paths.SubtermPath, - -- | The invalid binding name - invalidLetBindingNameErrorName :: Core.Name} - deriving (Eq, Ord, Read, Show) - -_InvalidLetBindingNameError = Core.Name "hydra.error.core.InvalidLetBindingNameError" - -_InvalidLetBindingNameError_location = Core.Name "location" - -_InvalidLetBindingNameError_name = Core.Name "name" - --- | A type lambda parameter name that violates naming conventions (optional) -data InvalidTypeLambdaParameterNameError = - InvalidTypeLambdaParameterNameError { - -- | The path to the type lambda within the term - invalidTypeLambdaParameterNameErrorLocation :: Paths.SubtermPath, - -- | The invalid type lambda parameter name - invalidTypeLambdaParameterNameErrorName :: Core.Name} - deriving (Eq, Ord, Read, Show) - -_InvalidTypeLambdaParameterNameError = Core.Name "hydra.error.core.InvalidTypeLambdaParameterNameError" - -_InvalidTypeLambdaParameterNameError_location = Core.Name "location" - -_InvalidTypeLambdaParameterNameError_name = Core.Name "name" - --- | A term annotation directly wrapping another term annotation; annotations should be merged (optional) -data NestedTermAnnotationError = - NestedTermAnnotationError { - -- | The path to the outer annotation within the term - nestedTermAnnotationErrorLocation :: Paths.SubtermPath} - deriving (Eq, Ord, Read, Show) - -_NestedTermAnnotationError = Core.Name "hydra.error.core.NestedTermAnnotationError" - -_NestedTermAnnotationError_location = Core.Name "location" - --- | An unwrap elimination applied to a wrap term of the same type, forming a no-op round-trip (optional) -data RedundantWrapUnwrapError = - RedundantWrapUnwrapError { - -- | The path to the redundant wrap/unwrap within the term - redundantWrapUnwrapErrorLocation :: Paths.SubtermPath, - -- | The type name of the wrapper - redundantWrapUnwrapErrorTypeName :: Core.Name} - deriving (Eq, Ord, Read, Show) - -_RedundantWrapUnwrapError = Core.Name "hydra.error.core.RedundantWrapUnwrapError" - -_RedundantWrapUnwrapError_location = Core.Name "location" - -_RedundantWrapUnwrapError_typeName = Core.Name "typeName" - --- | A variable applied to itself, which is almost always a mistake in Hydra's type system (optional) -data SelfApplicationError = - SelfApplicationError { - -- | The path to the self-application within the term - selfApplicationErrorLocation :: Paths.SubtermPath, - -- | The name of the variable applied to itself - selfApplicationErrorName :: Core.Name} - deriving (Eq, Ord, Read, Show) - -_SelfApplicationError = Core.Name "hydra.error.core.SelfApplicationError" - -_SelfApplicationError_location = Core.Name "location" - -_SelfApplicationError_name = Core.Name "name" - --- | A lambda parameter or let binding name that shadows a variable already in scope (optional) -data TermVariableShadowingError = - TermVariableShadowingError { - -- | The path to the shadowing binding within the term - termVariableShadowingErrorLocation :: Paths.SubtermPath, - -- | The name of the shadowed variable - termVariableShadowingErrorName :: Core.Name} - deriving (Eq, Ord, Read, Show) - -_TermVariableShadowingError = Core.Name "hydra.error.core.TermVariableShadowingError" - -_TermVariableShadowingError_location = Core.Name "location" - -_TermVariableShadowingError_name = Core.Name "name" - --- | A type lambda parameter that shadows a type variable already in scope (optional) -data TypeVariableShadowingInTypeLambdaError = - TypeVariableShadowingInTypeLambdaError { - -- | The path to the type lambda within the term - typeVariableShadowingInTypeLambdaErrorLocation :: Paths.SubtermPath, - -- | The name of the shadowed type variable - typeVariableShadowingInTypeLambdaErrorName :: Core.Name} - deriving (Eq, Ord, Read, Show) - -_TypeVariableShadowingInTypeLambdaError = Core.Name "hydra.error.core.TypeVariableShadowingInTypeLambdaError" - -_TypeVariableShadowingInTypeLambdaError_location = Core.Name "location" - -_TypeVariableShadowingInTypeLambdaError_name = Core.Name "name" - --- | A variable reference to a term name that is not bound in scope -data UndefinedTermVariableError = - UndefinedTermVariableError { - -- | The path to the undefined variable within the term - undefinedTermVariableErrorLocation :: Paths.SubtermPath, - -- | The name of the undefined variable - undefinedTermVariableErrorName :: Core.Name} - deriving (Eq, Ord, Read, Show) - -_UndefinedTermVariableError = Core.Name "hydra.error.core.UndefinedTermVariableError" - -_UndefinedTermVariableError_location = Core.Name "location" - -_UndefinedTermVariableError_name = Core.Name "name" - --- | A type variable in a let binding's type scheme that is not bound by the scheme or enclosing scope -data UndefinedTypeVariableInBindingTypeError = - UndefinedTypeVariableInBindingTypeError { - -- | The path to the binding within the term - undefinedTypeVariableInBindingTypeErrorLocation :: Paths.SubtermPath, - -- | The name of the undefined type variable - undefinedTypeVariableInBindingTypeErrorName :: Core.Name} - deriving (Eq, Ord, Read, Show) - -_UndefinedTypeVariableInBindingTypeError = Core.Name "hydra.error.core.UndefinedTypeVariableInBindingTypeError" - -_UndefinedTypeVariableInBindingTypeError_location = Core.Name "location" - -_UndefinedTypeVariableInBindingTypeError_name = Core.Name "name" - --- | A type variable in a lambda domain annotation that is not bound in scope -data UndefinedTypeVariableInLambdaDomainError = - UndefinedTypeVariableInLambdaDomainError { - -- | The path to the lambda within the term - undefinedTypeVariableInLambdaDomainErrorLocation :: Paths.SubtermPath, - -- | The name of the undefined type variable - undefinedTypeVariableInLambdaDomainErrorName :: Core.Name} - deriving (Eq, Ord, Read, Show) - -_UndefinedTypeVariableInLambdaDomainError = Core.Name "hydra.error.core.UndefinedTypeVariableInLambdaDomainError" - -_UndefinedTypeVariableInLambdaDomainError_location = Core.Name "location" - -_UndefinedTypeVariableInLambdaDomainError_name = Core.Name "name" - --- | A type variable in a type application term that is not bound in scope -data UndefinedTypeVariableInTypeApplicationError = - UndefinedTypeVariableInTypeApplicationError { - -- | The path to the type application within the term - undefinedTypeVariableInTypeApplicationErrorLocation :: Paths.SubtermPath, - -- | The name of the undefined type variable - undefinedTypeVariableInTypeApplicationErrorName :: Core.Name} - deriving (Eq, Ord, Read, Show) - -_UndefinedTypeVariableInTypeApplicationError = Core.Name "hydra.error.core.UndefinedTypeVariableInTypeApplicationError" - -_UndefinedTypeVariableInTypeApplicationError_location = Core.Name "location" - -_UndefinedTypeVariableInTypeApplicationError_name = Core.Name "name" - --- | A primitive function reference to a name not in the known primitive registry -data UnknownPrimitiveNameError = - UnknownPrimitiveNameError { - -- | The path to the primitive reference within the term - unknownPrimitiveNameErrorLocation :: Paths.SubtermPath, - -- | The unknown primitive name - unknownPrimitiveNameErrorName :: Core.Name} - deriving (Eq, Ord, Read, Show) - -_UnknownPrimitiveNameError = Core.Name "hydra.error.core.UnknownPrimitiveNameError" - -_UnknownPrimitiveNameError_location = Core.Name "location" - -_UnknownPrimitiveNameError_name = Core.Name "name" - --- | An application of an identity lambda to an argument, which simplifies to the argument (optional) -data UnnecessaryIdentityApplicationError = - UnnecessaryIdentityApplicationError { - -- | The path to the identity application within the term - unnecessaryIdentityApplicationErrorLocation :: Paths.SubtermPath} - deriving (Eq, Ord, Read, Show) - -_UnnecessaryIdentityApplicationError = Core.Name "hydra.error.core.UnnecessaryIdentityApplicationError" - -_UnnecessaryIdentityApplicationError_location = Core.Name "location" - --- | A term variable whose type is not known in the current scope -data UntypedTermVariableError = - UntypedTermVariableError { - -- | The path to the untyped variable within the term - untypedTermVariableErrorLocation :: Paths.SubtermPath, - -- | The name of the untyped variable - untypedTermVariableErrorName :: Core.Name} - deriving (Eq, Ord, Read, Show) - -_UntypedTermVariableError = Core.Name "hydra.error.core.UntypedTermVariableError" - -_UntypedTermVariableError_location = Core.Name "location" - -_UntypedTermVariableError_name = Core.Name "name" - --- | An error indicating that a term is invalid -data InvalidTermError = - -- | An ifElse with a literal boolean condition (optional) - InvalidTermErrorConstantCondition ConstantConditionError | - -- | A duplicate binding name in a let expression - InvalidTermErrorDuplicateBinding DuplicateBindingError | - -- | A duplicate field name in a record or case statement - InvalidTermErrorDuplicateField DuplicateFieldError | - -- | A case statement with no cases and no default (optional) - InvalidTermErrorEmptyCaseStatement EmptyCaseStatementError | - -- | A let expression with no bindings (optional) - InvalidTermErrorEmptyLetBindings EmptyLetBindingsError | - -- | A term annotation with an empty annotation map (optional) - InvalidTermErrorEmptyTermAnnotation EmptyTermAnnotationError | - -- | A term with an empty type name (optional) - InvalidTermErrorEmptyTypeNameInTerm EmptyTypeNameInTermError | - -- | A lambda parameter name violating naming conventions (optional) - InvalidTermErrorInvalidLambdaParameterName InvalidLambdaParameterNameError | - -- | A let binding name violating naming conventions (optional) - InvalidTermErrorInvalidLetBindingName InvalidLetBindingNameError | - -- | A type lambda parameter name violating naming conventions (optional) - InvalidTermErrorInvalidTypeLambdaParameterName InvalidTypeLambdaParameterNameError | - -- | Nested term annotations that should be merged (optional) - InvalidTermErrorNestedTermAnnotation NestedTermAnnotationError | - -- | A no-op unwrap-of-wrap round-trip (optional) - InvalidTermErrorRedundantWrapUnwrap RedundantWrapUnwrapError | - -- | A variable applied to itself (optional) - InvalidTermErrorSelfApplication SelfApplicationError | - -- | A binding that shadows a variable already in scope (optional) - InvalidTermErrorTermVariableShadowing TermVariableShadowingError | - -- | A type lambda parameter that shadows a type variable in scope (optional) - InvalidTermErrorTypeVariableShadowingInTypeLambda TypeVariableShadowingInTypeLambdaError | - -- | A variable reference to an unbound term name - InvalidTermErrorUndefinedTermVariable UndefinedTermVariableError | - -- | An unbound type variable in a let binding's type scheme - InvalidTermErrorUndefinedTypeVariableInBindingType UndefinedTypeVariableInBindingTypeError | - -- | An unbound type variable in a lambda domain annotation - InvalidTermErrorUndefinedTypeVariableInLambdaDomain UndefinedTypeVariableInLambdaDomainError | - -- | An unbound type variable in a type application term - InvalidTermErrorUndefinedTypeVariableInTypeApplication UndefinedTypeVariableInTypeApplicationError | - -- | A reference to an unknown primitive function - InvalidTermErrorUnknownPrimitiveName UnknownPrimitiveNameError | - -- | An identity lambda applied to an argument (optional) - InvalidTermErrorUnnecessaryIdentityApplication UnnecessaryIdentityApplicationError | - -- | A term variable whose type is not known - InvalidTermErrorUntypedTermVariable UntypedTermVariableError - deriving (Eq, Ord, Read, Show) - -_InvalidTermError = Core.Name "hydra.error.core.InvalidTermError" - -_InvalidTermError_constantCondition = Core.Name "constantCondition" - -_InvalidTermError_duplicateBinding = Core.Name "duplicateBinding" - -_InvalidTermError_duplicateField = Core.Name "duplicateField" - -_InvalidTermError_emptyCaseStatement = Core.Name "emptyCaseStatement" - -_InvalidTermError_emptyLetBindings = Core.Name "emptyLetBindings" - -_InvalidTermError_emptyTermAnnotation = Core.Name "emptyTermAnnotation" - -_InvalidTermError_emptyTypeNameInTerm = Core.Name "emptyTypeNameInTerm" - -_InvalidTermError_invalidLambdaParameterName = Core.Name "invalidLambdaParameterName" - -_InvalidTermError_invalidLetBindingName = Core.Name "invalidLetBindingName" - -_InvalidTermError_invalidTypeLambdaParameterName = Core.Name "invalidTypeLambdaParameterName" - -_InvalidTermError_nestedTermAnnotation = Core.Name "nestedTermAnnotation" - -_InvalidTermError_redundantWrapUnwrap = Core.Name "redundantWrapUnwrap" - -_InvalidTermError_selfApplication = Core.Name "selfApplication" - -_InvalidTermError_termVariableShadowing = Core.Name "termVariableShadowing" - -_InvalidTermError_typeVariableShadowingInTypeLambda = Core.Name "typeVariableShadowingInTypeLambda" - -_InvalidTermError_undefinedTermVariable = Core.Name "undefinedTermVariable" - -_InvalidTermError_undefinedTypeVariableInBindingType = Core.Name "undefinedTypeVariableInBindingType" - -_InvalidTermError_undefinedTypeVariableInLambdaDomain = Core.Name "undefinedTypeVariableInLambdaDomain" - -_InvalidTermError_undefinedTypeVariableInTypeApplication = Core.Name "undefinedTypeVariableInTypeApplication" - -_InvalidTermError_unknownPrimitiveName = Core.Name "unknownPrimitiveName" - -_InvalidTermError_unnecessaryIdentityApplication = Core.Name "unnecessaryIdentityApplication" - -_InvalidTermError_untypedTermVariable = Core.Name "untypedTermVariable" - --- | A record type with duplicate field names -data DuplicateRecordTypeFieldNamesError = - DuplicateRecordTypeFieldNamesError { - -- | The path to the record type with duplicate fields - duplicateRecordTypeFieldNamesErrorLocation :: Paths.SubtermPath, - -- | The duplicated field name - duplicateRecordTypeFieldNamesErrorName :: Core.Name} - deriving (Eq, Ord, Read, Show) - -_DuplicateRecordTypeFieldNamesError = Core.Name "hydra.error.core.DuplicateRecordTypeFieldNamesError" - -_DuplicateRecordTypeFieldNamesError_location = Core.Name "location" - -_DuplicateRecordTypeFieldNamesError_name = Core.Name "name" - --- | A union type with duplicate field names -data DuplicateUnionTypeFieldNamesError = - DuplicateUnionTypeFieldNamesError { - -- | The path to the union type with duplicate fields - duplicateUnionTypeFieldNamesErrorLocation :: Paths.SubtermPath, - -- | The duplicated field name - duplicateUnionTypeFieldNamesErrorName :: Core.Name} - deriving (Eq, Ord, Read, Show) - -_DuplicateUnionTypeFieldNamesError = Core.Name "hydra.error.core.DuplicateUnionTypeFieldNamesError" - -_DuplicateUnionTypeFieldNamesError_location = Core.Name "location" - -_DuplicateUnionTypeFieldNamesError_name = Core.Name "name" - --- | A record type with no fields; TypeUnit is preferred for the unit-like case (optional) -data EmptyRecordTypeError = - EmptyRecordTypeError { - -- | The path to the empty record type - emptyRecordTypeErrorLocation :: Paths.SubtermPath} - deriving (Eq, Ord, Read, Show) - -_EmptyRecordTypeError = Core.Name "hydra.error.core.EmptyRecordTypeError" - -_EmptyRecordTypeError_location = Core.Name "location" - --- | A type annotation with an empty annotation map (optional) -data EmptyTypeAnnotationError = - EmptyTypeAnnotationError { - -- | The path to the empty annotation - emptyTypeAnnotationErrorLocation :: Paths.SubtermPath} - deriving (Eq, Ord, Read, Show) - -_EmptyTypeAnnotationError = Core.Name "hydra.error.core.EmptyTypeAnnotationError" - -_EmptyTypeAnnotationError_location = Core.Name "location" - --- | A union type with no alternatives; TypeVoid is preferred (optional) -data EmptyUnionTypeError = - EmptyUnionTypeError { - -- | The path to the empty union type - emptyUnionTypeErrorLocation :: Paths.SubtermPath} - deriving (Eq, Ord, Read, Show) - -_EmptyUnionTypeError = Core.Name "hydra.error.core.EmptyUnionTypeError" - -_EmptyUnionTypeError_location = Core.Name "location" - --- | A forall type parameter name that violates type variable naming conventions (optional) -data InvalidForallParameterNameError = - InvalidForallParameterNameError { - -- | The path to the forall type - invalidForallParameterNameErrorLocation :: Paths.SubtermPath, - -- | The invalid parameter name - invalidForallParameterNameErrorName :: Core.Name} - deriving (Eq, Ord, Read, Show) - -_InvalidForallParameterNameError = Core.Name "hydra.error.core.InvalidForallParameterNameError" - -_InvalidForallParameterNameError_location = Core.Name "location" - -_InvalidForallParameterNameError_name = Core.Name "name" - --- | A type scheme variable name that violates type variable naming conventions (optional) -data InvalidTypeSchemeVariableNameError = - InvalidTypeSchemeVariableNameError { - -- | The path to the type scheme - invalidTypeSchemeVariableNameErrorLocation :: Paths.SubtermPath, - -- | The invalid variable name - invalidTypeSchemeVariableNameErrorName :: Core.Name} - deriving (Eq, Ord, Read, Show) - -_InvalidTypeSchemeVariableNameError = Core.Name "hydra.error.core.InvalidTypeSchemeVariableNameError" - -_InvalidTypeSchemeVariableNameError_location = Core.Name "location" - -_InvalidTypeSchemeVariableNameError_name = Core.Name "name" - --- | A type annotation directly wrapping another type annotation; annotations should be merged (optional) -data NestedTypeAnnotationError = - NestedTypeAnnotationError { - -- | The path to the outer annotation - nestedTypeAnnotationErrorLocation :: Paths.SubtermPath} - deriving (Eq, Ord, Read, Show) - -_NestedTypeAnnotationError = Core.Name "hydra.error.core.NestedTypeAnnotationError" - -_NestedTypeAnnotationError_location = Core.Name "location" - --- | A map type whose key type is or directly contains a function type, which cannot be compared for equality -data NonComparableMapKeyTypeError = - NonComparableMapKeyTypeError { - -- | The path to the map type - nonComparableMapKeyTypeErrorLocation :: Paths.SubtermPath, - -- | The non-comparable key type - nonComparableMapKeyTypeErrorKeyType :: Core.Type} - deriving (Eq, Ord, Read, Show) - -_NonComparableMapKeyTypeError = Core.Name "hydra.error.core.NonComparableMapKeyTypeError" - -_NonComparableMapKeyTypeError_location = Core.Name "location" - -_NonComparableMapKeyTypeError_keyType = Core.Name "keyType" - --- | A set type whose element type is or directly contains a function type, which cannot be compared for equality -data NonComparableSetElementTypeError = - NonComparableSetElementTypeError { - -- | The path to the set type - nonComparableSetElementTypeErrorLocation :: Paths.SubtermPath, - -- | The non-comparable element type - nonComparableSetElementTypeErrorElementType :: Core.Type} - deriving (Eq, Ord, Read, Show) - -_NonComparableSetElementTypeError = Core.Name "hydra.error.core.NonComparableSetElementTypeError" - -_NonComparableSetElementTypeError_location = Core.Name "location" - -_NonComparableSetElementTypeError_elementType = Core.Name "elementType" - --- | A union type with exactly one field; could be a wrapped type or record instead (optional) -data SingleVariantUnionError = - SingleVariantUnionError { - -- | The path to the single-variant union type - singleVariantUnionErrorLocation :: Paths.SubtermPath, - -- | The name of the single field - singleVariantUnionErrorFieldName :: Core.Name} - deriving (Eq, Ord, Read, Show) - -_SingleVariantUnionError = Core.Name "hydra.error.core.SingleVariantUnionError" - -_SingleVariantUnionError_location = Core.Name "location" - -_SingleVariantUnionError_fieldName = Core.Name "fieldName" - --- | A forall type parameter that shadows a type variable already in scope (optional) -data TypeVariableShadowingInForallError = - TypeVariableShadowingInForallError { - -- | The path to the shadowing forall type - typeVariableShadowingInForallErrorLocation :: Paths.SubtermPath, - -- | The name of the shadowed type variable - typeVariableShadowingInForallErrorName :: Core.Name} - deriving (Eq, Ord, Read, Show) - -_TypeVariableShadowingInForallError = Core.Name "hydra.error.core.TypeVariableShadowingInForallError" - -_TypeVariableShadowingInForallError_location = Core.Name "location" - -_TypeVariableShadowingInForallError_name = Core.Name "name" - --- | A type variable reference to a name that is not bound in scope -data UndefinedTypeVariableError = - UndefinedTypeVariableError { - -- | The path to the undefined type variable - undefinedTypeVariableErrorLocation :: Paths.SubtermPath, - -- | The name of the undefined type variable - undefinedTypeVariableErrorName :: Core.Name} - deriving (Eq, Ord, Read, Show) - -_UndefinedTypeVariableError = Core.Name "hydra.error.core.UndefinedTypeVariableError" - -_UndefinedTypeVariableError_location = Core.Name "location" - -_UndefinedTypeVariableError_name = Core.Name "name" - --- | TypeVoid appearing in a position where no value can be constructed, such as a record field, list element, map key/value, set element, pair component, or function codomain (optional) -data VoidInNonBottomPositionError = - VoidInNonBottomPositionError { - -- | The path to the void type in a non-bottom position - voidInNonBottomPositionErrorLocation :: Paths.SubtermPath} - deriving (Eq, Ord, Read, Show) - -_VoidInNonBottomPositionError = Core.Name "hydra.error.core.VoidInNonBottomPositionError" - -_VoidInNonBottomPositionError_location = Core.Name "location" - --- | An error indicating that a type is invalid -data InvalidTypeError = - -- | A record type with duplicate field names - InvalidTypeErrorDuplicateRecordTypeFieldNames DuplicateRecordTypeFieldNamesError | - -- | A union type with duplicate field names - InvalidTypeErrorDuplicateUnionTypeFieldNames DuplicateUnionTypeFieldNamesError | - -- | A record type with no fields (optional) - InvalidTypeErrorEmptyRecordType EmptyRecordTypeError | - -- | A type annotation with an empty annotation map (optional) - InvalidTypeErrorEmptyTypeAnnotation EmptyTypeAnnotationError | - -- | A union type with no alternatives (optional) - InvalidTypeErrorEmptyUnionType EmptyUnionTypeError | - -- | A forall parameter name violating naming conventions (optional) - InvalidTypeErrorInvalidForallParameterName InvalidForallParameterNameError | - -- | A type scheme variable name violating naming conventions (optional) - InvalidTypeErrorInvalidTypeSchemeVariableName InvalidTypeSchemeVariableNameError | - -- | Nested type annotations that should be merged (optional) - InvalidTypeErrorNestedTypeAnnotation NestedTypeAnnotationError | - -- | A map with a non-comparable key type - InvalidTypeErrorNonComparableMapKeyType NonComparableMapKeyTypeError | - -- | A set with a non-comparable element type - InvalidTypeErrorNonComparableSetElementType NonComparableSetElementTypeError | - -- | A union type with only one variant (optional) - InvalidTypeErrorSingleVariantUnion SingleVariantUnionError | - -- | A forall parameter that shadows a type variable in scope (optional) - InvalidTypeErrorTypeVariableShadowingInForall TypeVariableShadowingInForallError | - -- | A type variable reference to an unbound name - InvalidTypeErrorUndefinedTypeVariable UndefinedTypeVariableError | - -- | TypeVoid in a position where no value can be constructed (optional) - InvalidTypeErrorVoidInNonBottomPosition VoidInNonBottomPositionError - deriving (Eq, Ord, Read, Show) - -_InvalidTypeError = Core.Name "hydra.error.core.InvalidTypeError" - -_InvalidTypeError_duplicateRecordTypeFieldNames = Core.Name "duplicateRecordTypeFieldNames" - -_InvalidTypeError_duplicateUnionTypeFieldNames = Core.Name "duplicateUnionTypeFieldNames" - -_InvalidTypeError_emptyRecordType = Core.Name "emptyRecordType" - -_InvalidTypeError_emptyTypeAnnotation = Core.Name "emptyTypeAnnotation" - -_InvalidTypeError_emptyUnionType = Core.Name "emptyUnionType" - -_InvalidTypeError_invalidForallParameterName = Core.Name "invalidForallParameterName" - -_InvalidTypeError_invalidTypeSchemeVariableName = Core.Name "invalidTypeSchemeVariableName" - -_InvalidTypeError_nestedTypeAnnotation = Core.Name "nestedTypeAnnotation" - -_InvalidTypeError_nonComparableMapKeyType = Core.Name "nonComparableMapKeyType" - -_InvalidTypeError_nonComparableSetElementType = Core.Name "nonComparableSetElementType" - -_InvalidTypeError_singleVariantUnion = Core.Name "singleVariantUnion" - -_InvalidTypeError_typeVariableShadowingInForall = Core.Name "typeVariableShadowingInForall" - -_InvalidTypeError_undefinedTypeVariable = Core.Name "undefinedTypeVariable" - -_InvalidTypeError_voidInNonBottomPosition = Core.Name "voidInNonBottomPosition" diff --git a/src/gen-main/haskell/Hydra/Error/Packaging.hs b/src/gen-main/haskell/Hydra/Error/Packaging.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Error/Packaging.hs +++ /dev/null @@ -1,129 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Error types for module and package validation - -module Hydra.Error.Packaging where - -import qualified Hydra.Core as Core -import qualified Hydra.Module as Module -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | A module namespace which, when mapped to a target language's directory or package structure, conflicts with another module's mapped namespace. For example, hydra.foo.bar and hydra.fooBar might both map to the same directory in a case-insensitive filesystem. -data ConflictingModuleNamespaceError = - ConflictingModuleNamespaceError { - -- | The first module namespace - conflictingModuleNamespaceErrorFirst :: Module.Namespace, - -- | The second module namespace that conflicts with the first - conflictingModuleNamespaceErrorSecond :: Module.Namespace} - deriving (Eq, Ord, Read, Show) - -_ConflictingModuleNamespaceError = Core.Name "hydra.error.packaging.ConflictingModuleNamespaceError" - -_ConflictingModuleNamespaceError_first = Core.Name "first" - -_ConflictingModuleNamespaceError_second = Core.Name "second" - --- | A union type variant name which, when capitalized and concatenated with its type name, conflicts with another type definition name. For example, a union type Foo with a variant bar produces FooBar, which conflicts with an existing type definition FooBar. This is currently a problem only for the Haskell target. -data ConflictingVariantNameError = - ConflictingVariantNameError { - -- | The namespace of the module containing the conflict - conflictingVariantNameErrorNamespace :: Module.Namespace, - -- | The name of the union type - conflictingVariantNameErrorTypeName :: Core.Name, - -- | The name of the variant field causing the conflict - conflictingVariantNameErrorVariantName :: Core.Name, - -- | The name of the other type definition that conflicts with the generated constructor name - conflictingVariantNameErrorConflictingName :: Core.Name} - deriving (Eq, Ord, Read, Show) - -_ConflictingVariantNameError = Core.Name "hydra.error.packaging.ConflictingVariantNameError" - -_ConflictingVariantNameError_namespace = Core.Name "namespace" - -_ConflictingVariantNameError_typeName = Core.Name "typeName" - -_ConflictingVariantNameError_variantName = Core.Name "variantName" - -_ConflictingVariantNameError_conflictingName = Core.Name "conflictingName" - --- | A definition whose name does not have the module's namespace as a prefix. If the module namespace is foo.bar, all definition names must have the form foo.bar.quux. -data DefinitionNotInModuleNamespaceError = - DefinitionNotInModuleNamespaceError { - -- | The namespace of the module - definitionNotInModuleNamespaceErrorNamespace :: Module.Namespace, - -- | The definition name that does not match the module namespace - definitionNotInModuleNamespaceErrorName :: Core.Name} - deriving (Eq, Ord, Read, Show) - -_DefinitionNotInModuleNamespaceError = Core.Name "hydra.error.packaging.DefinitionNotInModuleNamespaceError" - -_DefinitionNotInModuleNamespaceError_namespace = Core.Name "namespace" - -_DefinitionNotInModuleNamespaceError_name = Core.Name "name" - --- | Two or more definitions in the same module share the same name -data DuplicateDefinitionNameError = - DuplicateDefinitionNameError { - -- | The namespace of the module containing the duplicates - duplicateDefinitionNameErrorNamespace :: Module.Namespace, - -- | The duplicated definition name - duplicateDefinitionNameErrorName :: Core.Name} - deriving (Eq, Ord, Read, Show) - -_DuplicateDefinitionNameError = Core.Name "hydra.error.packaging.DuplicateDefinitionNameError" - -_DuplicateDefinitionNameError_namespace = Core.Name "namespace" - -_DuplicateDefinitionNameError_name = Core.Name "name" - --- | Two or more modules in the same package share the same namespace -data DuplicateModuleNamespaceError = - DuplicateModuleNamespaceError { - -- | The duplicated module namespace - duplicateModuleNamespaceErrorNamespace :: Module.Namespace} - deriving (Eq, Ord, Read, Show) - -_DuplicateModuleNamespaceError = Core.Name "hydra.error.packaging.DuplicateModuleNamespaceError" - -_DuplicateModuleNamespaceError_namespace = Core.Name "namespace" - --- | An error indicating that a module is invalid -data InvalidModuleError = - -- | A union variant name that conflicts with another type definition when mapped to a target language - InvalidModuleErrorConflictingVariantName ConflictingVariantNameError | - -- | A definition whose name does not have the module's namespace as a prefix - InvalidModuleErrorDefinitionNotInModuleNamespace DefinitionNotInModuleNamespaceError | - -- | Two or more definitions in the same module share the same name - InvalidModuleErrorDuplicateDefinitionName DuplicateDefinitionNameError - deriving (Eq, Ord, Read, Show) - -_InvalidModuleError = Core.Name "hydra.error.packaging.InvalidModuleError" - -_InvalidModuleError_conflictingVariantName = Core.Name "conflictingVariantName" - -_InvalidModuleError_definitionNotInModuleNamespace = Core.Name "definitionNotInModuleNamespace" - -_InvalidModuleError_duplicateDefinitionName = Core.Name "duplicateDefinitionName" - --- | An error indicating that a package is invalid -data InvalidPackageError = - -- | Two module namespaces that conflict when mapped to a target language - InvalidPackageErrorConflictingModuleNamespace ConflictingModuleNamespaceError | - -- | Two or more modules in the same package share the same namespace - InvalidPackageErrorDuplicateModuleNamespace DuplicateModuleNamespaceError | - -- | A module within the package is invalid - InvalidPackageErrorInvalidModule InvalidModuleError - deriving (Eq, Ord, Read, Show) - -_InvalidPackageError = Core.Name "hydra.error.packaging.InvalidPackageError" - -_InvalidPackageError_conflictingModuleNamespace = Core.Name "conflictingModuleNamespace" - -_InvalidPackageError_duplicateModuleNamespace = Core.Name "duplicateModuleNamespace" - -_InvalidPackageError_invalidModule = Core.Name "invalidModule" diff --git a/src/gen-main/haskell/Hydra/Errors.hs b/src/gen-main/haskell/Hydra/Errors.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Errors.hs +++ /dev/null @@ -1,100 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Top-level error types for the Hydra kernel - -module Hydra.Errors where - -import qualified Hydra.Core as Core -import qualified Hydra.Error.Checking as Checking -import qualified Hydra.Error.Core as Core_ -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | An error that occurred during decoding of a term -newtype DecodingError = - DecodingError { - unDecodingError :: String} - deriving (Eq, Ord, Read, Show) - -_DecodingError = Core.Name "hydra.errors.DecodingError" - --- | An error of any kind, with kernel errors particularly differentiated -data Error = - -- | A type checking error - ErrorChecking Checking.CheckingError | - -- | An error that occurred during decoding of a term - ErrorDecoding DecodingError | - -- | A duplicate binding name error - ErrorDuplicateBinding Core_.DuplicateBindingError | - -- | A duplicate field name error - ErrorDuplicateField Core_.DuplicateFieldError | - -- | Any other error - ErrorOther OtherError | - -- | A reference to an undefined field - ErrorUndefinedField Core_.UndefinedFieldError | - -- | A reference to an undefined term variable - ErrorUndefinedTermVariable Core_.UndefinedTermVariableError | - -- | A term variable whose type is not known - ErrorUntypedTermVariable Core_.UntypedTermVariableError | - -- | An unexpected term variant - ErrorUnexpectedTermVariant Core_.UnexpectedTermVariantError | - -- | An unexpected type variant - ErrorUnexpectedTypeVariant Core_.UnexpectedTypeVariantError | - -- | A type unification error - ErrorUnification UnificationError - deriving (Eq, Ord, Read, Show) - -_Error = Core.Name "hydra.errors.Error" - -_Error_checking = Core.Name "checking" - -_Error_decoding = Core.Name "decoding" - -_Error_duplicateBinding = Core.Name "duplicateBinding" - -_Error_duplicateField = Core.Name "duplicateField" - -_Error_other = Core.Name "other" - -_Error_undefinedField = Core.Name "undefinedField" - -_Error_undefinedTermVariable = Core.Name "undefinedTermVariable" - -_Error_untypedTermVariable = Core.Name "untypedTermVariable" - -_Error_unexpectedTermVariant = Core.Name "unexpectedTermVariant" - -_Error_unexpectedTypeVariant = Core.Name "unexpectedTypeVariant" - -_Error_unification = Core.Name "unification" - --- | Any other error -newtype OtherError = - OtherError { - unOtherError :: String} - deriving (Eq, Ord, Read, Show) - -_OtherError = Core.Name "hydra.errors.OtherError" - --- | An error that occurred during type unification -data UnificationError = - UnificationError { - -- | The left-hand type in the unification - unificationErrorLeftType :: Core.Type, - -- | The right-hand type in the unification - unificationErrorRightType :: Core.Type, - -- | A human-readable error message - unificationErrorMessage :: String} - deriving (Eq, Ord, Read, Show) - -_UnificationError = Core.Name "hydra.errors.UnificationError" - -_UnificationError_leftType = Core.Name "leftType" - -_UnificationError_rightType = Core.Name "rightType" - -_UnificationError_message = Core.Name "message" diff --git a/src/gen-main/haskell/Hydra/Eval/Lib/Eithers.hs b/src/gen-main/haskell/Hydra/Eval/Lib/Eithers.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Eval/Lib/Eithers.hs +++ /dev/null @@ -1,246 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Evaluation-level implementations of Either functions for the Hydra interpreter. - -module Hydra.Eval.Lib.Eithers where - -import qualified Hydra.Context as Context -import qualified Hydra.Core as Core -import qualified Hydra.Errors as Errors -import qualified Hydra.Extract.Core as Core_ -import qualified Hydra.Graph as Graph -import qualified Hydra.Lib.Eithers as Eithers -import qualified Hydra.Lib.Lists as Lists -import qualified Hydra.Lib.Maybes as Maybes -import qualified Hydra.Lib.Pairs as Pairs -import qualified Hydra.Lib.Sets as Sets -import qualified Hydra.Lib.Strings as Strings -import qualified Hydra.Show.Core as Core__ -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | Interpreter-friendly bimap for Either terms. -bimap :: Context.Context -> t0 -> Core.Term -> Core.Term -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -bimap cx g leftFun rightFun eitherTerm = - case eitherTerm of - Core.TermEither v0 -> Right (Eithers.either (\val -> Core.TermEither (Left (Core.TermApplication (Core.Application { - Core.applicationFunction = leftFun, - Core.applicationArgument = val})))) (\val -> Core.TermEither (Right (Core.TermApplication (Core.Application { - Core.applicationFunction = rightFun, - Core.applicationArgument = val})))) v0) - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "either value") " but found ") (Core__.term eitherTerm)))), - Context.inContextContext = cx}) - --- | Interpreter-friendly bind for Either terms. -bind :: Context.Context -> t0 -> Core.Term -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -bind cx g eitherTerm funTerm = - case eitherTerm of - Core.TermEither v0 -> Right (Eithers.either (\val -> Core.TermEither (Left val)) (\val -> Core.TermApplication (Core.Application { - Core.applicationFunction = funTerm, - Core.applicationArgument = val})) v0) - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "either value") " but found ") (Core__.term eitherTerm)))), - Context.inContextContext = cx}) - --- | Interpreter-friendly case analysis for Either terms. -either :: Context.Context -> t0 -> Core.Term -> Core.Term -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -either cx g leftFun rightFun eitherTerm = - case eitherTerm of - Core.TermEither v0 -> Right (Eithers.either (\val -> Core.TermApplication (Core.Application { - Core.applicationFunction = leftFun, - Core.applicationArgument = val})) (\val -> Core.TermApplication (Core.Application { - Core.applicationFunction = rightFun, - Core.applicationArgument = val})) v0) - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "either value") " but found ") (Core__.term eitherTerm)))), - Context.inContextContext = cx}) - --- | Interpreter-friendly foldl for Either. -foldl :: Context.Context -> Graph.Graph -> Core.Term -> Core.Term -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -foldl cx g funTerm initTerm listTerm = - Eithers.bind (Core_.list cx g listTerm) (\elements -> Right (Lists.foldl (\acc -> \el -> Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "a"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = funTerm, - Core.applicationArgument = (Core.TermVariable (Core.Name "a"))})), - Core.applicationArgument = el}))})))})), - Core.applicationArgument = acc})) (Core.TermEither (Right initTerm)) elements)) - --- | Interpreter-friendly fromLeft for Either terms. -fromLeft :: Context.Context -> t0 -> Core.Term -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -fromLeft cx g defaultTerm eitherTerm = - case eitherTerm of - Core.TermEither v0 -> Right (Eithers.either (\val -> val) (\_ -> defaultTerm) v0) - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "either value") " but found ") (Core__.term eitherTerm)))), - Context.inContextContext = cx}) - --- | Interpreter-friendly fromRight for Either terms. -fromRight :: Context.Context -> t0 -> Core.Term -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -fromRight cx g defaultTerm eitherTerm = - case eitherTerm of - Core.TermEither v0 -> Right (Eithers.either (\_ -> defaultTerm) (\val -> val) v0) - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "either value") " but found ") (Core__.term eitherTerm)))), - Context.inContextContext = cx}) - --- | Interpreter-friendly isLeft for Either terms. -isLeft :: Context.Context -> t0 -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -isLeft cx g eitherTerm = - case eitherTerm of - Core.TermEither v0 -> Right (Eithers.either (\_ -> Core.TermLiteral (Core.LiteralBoolean True)) (\_ -> Core.TermLiteral (Core.LiteralBoolean False)) v0) - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "either value") " but found ") (Core__.term eitherTerm)))), - Context.inContextContext = cx}) - --- | Interpreter-friendly isRight for Either terms. -isRight :: Context.Context -> t0 -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -isRight cx g eitherTerm = - case eitherTerm of - Core.TermEither v0 -> Right (Eithers.either (\_ -> Core.TermLiteral (Core.LiteralBoolean False)) (\_ -> Core.TermLiteral (Core.LiteralBoolean True)) v0) - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "either value") " but found ") (Core__.term eitherTerm)))), - Context.inContextContext = cx}) - --- | Interpreter-friendly lefts for list of Either terms. -lefts :: Context.Context -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -lefts cx g listTerm = - Eithers.bind (Core_.list cx g listTerm) (\elements -> Right (Core.TermList (Lists.foldl (\acc -> \el -> case el of - Core.TermEither v0 -> Eithers.either (\val -> Lists.concat2 acc (Lists.pure val)) (\_ -> acc) v0 - _ -> acc) [] elements))) - --- | Interpreter-friendly map for Either terms. -map :: Context.Context -> t0 -> Core.Term -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -map cx g rightFun eitherTerm = - case eitherTerm of - Core.TermEither v0 -> Right (Eithers.either (\val -> Core.TermEither (Left val)) (\val -> Core.TermEither (Right (Core.TermApplication (Core.Application { - Core.applicationFunction = rightFun, - Core.applicationArgument = val})))) v0) - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "either value") " but found ") (Core__.term eitherTerm)))), - Context.inContextContext = cx}) - --- | Interpreter-friendly mapList for Either (traverse). -mapList :: Context.Context -> Graph.Graph -> Core.Term -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -mapList cx g funTerm listTerm = - Eithers.bind (Core_.list cx g listTerm) (\elements -> Right (Lists.foldl (\acc -> \el -> Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "accErr"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "accErr"))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "ys"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.lists.cons"))), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "ys"))}))))})))})), - Core.applicationArgument = acc}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = funTerm, - Core.applicationArgument = el}))})) (Core.TermEither (Right (Core.TermList []))) (Lists.reverse elements))) - --- | Interpreter-friendly mapMaybe for Either (traverse over Maybe). -mapMaybe :: Context.Context -> t0 -> Core.Term -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -mapMaybe cx g funTerm maybeTerm = - case maybeTerm of - Core.TermMaybe v0 -> Right (Maybes.maybe (Core.TermEither (Right (Core.TermMaybe Nothing))) (\val -> Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermMaybe (Just (Core.TermVariable (Core.Name "y"))))))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = funTerm, - Core.applicationArgument = val}))})) v0) - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "maybe value") " but found ") (Core__.term maybeTerm)))), - Context.inContextContext = cx}) - --- | Interpreter-friendly mapSet for Either (traverse over Set). -mapSet :: Context.Context -> Graph.Graph -> Core.Term -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -mapSet cx g funTerm setTerm = - Eithers.bind (Core_.set cx g setTerm) (\elements -> Right (Lists.foldl (\acc -> \el -> Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "accErr"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "accErr"))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "ys"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.sets.insert"))), - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "ys"))}))))})))})), - Core.applicationArgument = acc}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = funTerm, - Core.applicationArgument = el}))})) (Core.TermEither (Right (Core.TermSet (Sets.fromList [])))) (Sets.toList elements))) - --- | Interpreter-friendly partitionEithers for list of Either terms. -partitionEithers :: Context.Context -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) ([Core.Term], [Core.Term]) -partitionEithers cx g listTerm = - Eithers.bind (Core_.list cx g listTerm) (\elements -> Right (Lists.foldl (\acc -> \el -> - let ls = Pairs.first acc - rs = Pairs.second acc - in case el of - Core.TermEither v0 -> Eithers.either (\val -> (Lists.concat2 ls (Lists.pure val), rs)) (\val -> (ls, (Lists.concat2 rs (Lists.pure val)))) v0 - _ -> acc) ([], []) elements)) - --- | Interpreter-friendly rights for list of Either terms. -rights :: Context.Context -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -rights cx g listTerm = - Eithers.bind (Core_.list cx g listTerm) (\elements -> Right (Core.TermList (Lists.foldl (\acc -> \el -> case el of - Core.TermEither v0 -> Eithers.either (\_ -> acc) (\val -> Lists.concat2 acc (Lists.pure val)) v0 - _ -> acc) [] elements))) diff --git a/src/gen-main/haskell/Hydra/Eval/Lib/Equality.hs b/src/gen-main/haskell/Hydra/Eval/Lib/Equality.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Eval/Lib/Equality.hs +++ /dev/null @@ -1,47 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Evaluation-level implementations of Equality functions for the Hydra interpreter. - -module Hydra.Eval.Lib.Equality where - -import qualified Hydra.Core as Core -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | Interpreter-friendly identity function. -identity :: t0 -> t1 -> t2 -> Either t3 t2 -identity cx g x = Right x - --- | Interpreter-friendly max. -max :: t0 -> t1 -> Core.Term -> Core.Term -> Either t2 Core.Term -max cx g x y = - Right (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.logic.ifElse"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.equality.gte"))), - Core.applicationArgument = x})), - Core.applicationArgument = y}))})), - Core.applicationArgument = x})), - Core.applicationArgument = y})) - --- | Interpreter-friendly min. -min :: t0 -> t1 -> Core.Term -> Core.Term -> Either t2 Core.Term -min cx g x y = - Right (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.logic.ifElse"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.equality.lte"))), - Core.applicationArgument = x})), - Core.applicationArgument = y}))})), - Core.applicationArgument = x})), - Core.applicationArgument = y})) diff --git a/src/gen-main/haskell/Hydra/Eval/Lib/Lists.hs b/src/gen-main/haskell/Hydra/Eval/Lib/Lists.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Eval/Lib/Lists.hs +++ /dev/null @@ -1,445 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Evaluation-level implementations of List functions for the Hydra interpreter. - -module Hydra.Eval.Lib.Lists where - -import qualified Hydra.Context as Context -import qualified Hydra.Core as Core -import qualified Hydra.Errors as Errors -import qualified Hydra.Extract.Core as Core_ -import qualified Hydra.Graph as Graph -import qualified Hydra.Lib.Eithers as Eithers -import qualified Hydra.Lib.Lists as Lists -import qualified Hydra.Lib.Logic as Logic -import qualified Hydra.Lib.Pairs as Pairs -import qualified Hydra.Reduction as Reduction -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | Interpreter-friendly applicative apply for List terms. -apply :: Context.Context -> Graph.Graph -> Core.Term -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -apply cx g funsTerm argsTerm = - Eithers.bind (Core_.list cx g funsTerm) (\funs -> Eithers.bind (Core_.list cx g argsTerm) (\arguments -> - let applyOne = - \f -> Lists.map (\arg -> Core.TermApplication (Core.Application { - Core.applicationFunction = f, - Core.applicationArgument = arg})) arguments - in (Right (Core.TermList (Lists.concat (Lists.map applyOne funs)))))) - --- | Interpreter-friendly monadic bind for List terms. -bind :: Context.Context -> Graph.Graph -> Core.Term -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -bind cx g listTerm funTerm = - Eithers.bind (Core_.list cx g listTerm) (\elements -> Right (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.lists.concat"))), - Core.applicationArgument = (Core.TermList (Lists.map (\el -> Core.TermApplication (Core.Application { - Core.applicationFunction = funTerm, - Core.applicationArgument = el})) elements))}))) - --- | Interpreter-friendly concat2 for List terms. -concat2 :: t0 -> t1 -> Core.Term -> Core.Term -> Either t2 Core.Term -concat2 cx g list1 list2 = - Right (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.lists.concat"))), - Core.applicationArgument = (Core.TermList [ - list1, - list2])})) - --- | Interpreter-friendly dropWhile for List terms. -dropWhile :: t0 -> t1 -> Core.Term -> Core.Term -> Either t2 Core.Term -dropWhile cx g predTerm listTerm = - Right (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.pairs.second"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.lists.span"))), - Core.applicationArgument = predTerm})), - Core.applicationArgument = listTerm}))})) - --- | Interpreter-friendly elem for List terms. -elem :: t0 -> t1 -> Core.Term -> Core.Term -> Either t2 Core.Term -elem cx g x listTerm = - Right (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maybes.isJust"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.lists.find"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.equality.equal"))), - Core.applicationArgument = x}))})), - Core.applicationArgument = listTerm}))})) - --- | Interpreter-friendly filter for List terms. -filter :: Context.Context -> Graph.Graph -> Core.Term -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -filter cx g predTerm listTerm = - Eithers.bind (Core_.list cx g listTerm) (\elements -> Right (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.lists.concat"))), - Core.applicationArgument = (Core.TermList (Lists.map (\el -> Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.logic.ifElse"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = predTerm, - Core.applicationArgument = el}))})), - Core.applicationArgument = (Core.TermList (Lists.pure el))})), - Core.applicationArgument = (Core.TermList [])})) elements))}))) - --- | Interpreter-friendly find for List terms. -find :: t0 -> t1 -> Core.Term -> Core.Term -> Either t2 Core.Term -find cx g predTerm listTerm = - Right (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.lists.safeHead"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.lists.filter"))), - Core.applicationArgument = predTerm})), - Core.applicationArgument = listTerm}))})) - --- | Interpreter-friendly left fold for List terms. -foldl :: Context.Context -> Graph.Graph -> Core.Term -> Core.Term -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -foldl cx g funTerm initTerm listTerm = - Eithers.bind (Core_.list cx g listTerm) (\elements -> Lists.foldl (\acc -> \el -> Eithers.bind acc (\reducedAcc -> Reduction.reduceTerm cx g True (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = funTerm, - Core.applicationArgument = reducedAcc})), - Core.applicationArgument = el})))) (Right initTerm) elements) - --- | Interpreter-friendly right fold for List terms. -foldr :: Context.Context -> Graph.Graph -> Core.Term -> Core.Term -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -foldr cx g funTerm initTerm listTerm = - Eithers.bind (Core_.list cx g listTerm) (\elements -> Lists.foldr (\el -> \acc -> Eithers.bind acc (\reducedAcc -> Reduction.reduceTerm cx g True (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = funTerm, - Core.applicationArgument = el})), - Core.applicationArgument = reducedAcc})))) (Right initTerm) elements) - --- | Interpreter-friendly group for List terms. -group :: t0 -> t1 -> Core.Term -> Either t2 Core.Term -group cx g listTerm = - Right (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "foldResult"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.logic.ifElse"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.lists.null"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.pairs.first"))), - Core.applicationArgument = (Core.TermVariable (Core.Name "foldResult"))}))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.pairs.second"))), - Core.applicationArgument = (Core.TermVariable (Core.Name "foldResult"))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.lists.concat2"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.pairs.second"))), - Core.applicationArgument = (Core.TermVariable (Core.Name "foldResult"))}))})), - Core.applicationArgument = (Core.TermList [ - Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.pairs.first"))), - Core.applicationArgument = (Core.TermVariable (Core.Name "foldResult"))})])}))}))}))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.lists.foldl"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "acc"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "el"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maybes.maybe"))), - Core.applicationArgument = (Core.TermPair (Core.TermList [ - Core.TermVariable (Core.Name "el")], (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.pairs.second"))), - Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "h"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.logic.ifElse"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.equality.equal"))), - Core.applicationArgument = (Core.TermVariable (Core.Name "el"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "h"))}))})), - Core.applicationArgument = (Core.TermPair (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.lists.concat2"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.pairs.first"))), - Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))})), - Core.applicationArgument = (Core.TermList [ - Core.TermVariable (Core.Name "el")])}), (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.pairs.second"))), - Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))))})), - Core.applicationArgument = (Core.TermPair (Core.TermList [ - Core.TermVariable (Core.Name "el")], (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.lists.concat2"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.pairs.second"))), - Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))})), - Core.applicationArgument = (Core.TermList [ - Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.pairs.first"))), - Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))})])}))))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.lists.safeHead"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.pairs.first"))), - Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))}))}))})))})))})), - Core.applicationArgument = (Core.TermPair (Core.TermList [], (Core.TermList [])))})), - Core.applicationArgument = listTerm}))})) - --- | Interpreter-friendly intercalate for List terms. -intercalate :: t0 -> t1 -> Core.Term -> Core.Term -> Either t2 Core.Term -intercalate cx g sep listsTerm = - Right (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.lists.concat"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.lists.intersperse"))), - Core.applicationArgument = sep})), - Core.applicationArgument = listsTerm}))})) - --- | Interpreter-friendly intersperse for List terms. -intersperse :: Context.Context -> Graph.Graph -> Core.Term -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -intersperse cx g sep listTerm = - Eithers.bind (Core_.list cx g listTerm) (\elements -> Right (Logic.ifElse (Lists.null elements) (Core.TermList []) (Core.TermList (Lists.cons (Lists.head elements) (Lists.concat (Lists.map (\el -> [ - sep, - el]) (Lists.tail elements))))))) - --- | Interpreter-friendly map for List terms. -map :: Context.Context -> Graph.Graph -> Core.Term -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -map cx g funTerm listTerm = - Eithers.bind (Core_.list cx g listTerm) (\elements -> Right (Core.TermList (Lists.reverse (Lists.foldl (\acc -> \el -> Lists.cons (Core.TermApplication (Core.Application { - Core.applicationFunction = funTerm, - Core.applicationArgument = el})) acc) [] elements)))) - --- | Interpreter-friendly nub for List terms. -nub :: Context.Context -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -nub cx g listTerm = - Eithers.bind (Core_.list cx g listTerm) (\elements -> Right (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.lists.foldl"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "acc"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "x"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.logic.ifElse"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.lists.elem"))), - Core.applicationArgument = (Core.TermVariable (Core.Name "x"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.lists.concat2"))), - Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))})), - Core.applicationArgument = (Core.TermList [ - Core.TermVariable (Core.Name "x")])}))}))})))})))})), - Core.applicationArgument = (Core.TermList [])})), - Core.applicationArgument = listTerm}))) - --- | Interpreter-friendly partition for List terms. -partition :: Context.Context -> Graph.Graph -> Core.Term -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -partition cx g predTerm listTerm = - Eithers.bind (Core_.list cx g listTerm) (\elements -> - let initialState = Core.TermPair (Core.TermList [], (Core.TermList [])) - finalState = - Lists.foldl (\acc -> \el -> - let yeses = - Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.pairs.first"))), - Core.applicationArgument = acc}) - nos = - Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.pairs.second"))), - Core.applicationArgument = acc}) - in (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.logic.ifElse"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = predTerm, - Core.applicationArgument = el}))})), - Core.applicationArgument = (Core.TermPair (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.lists.concat2"))), - Core.applicationArgument = yeses})), - Core.applicationArgument = (Core.TermList [ - el])}), nos))})), - Core.applicationArgument = (Core.TermPair (yeses, (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.lists.concat2"))), - Core.applicationArgument = nos})), - Core.applicationArgument = (Core.TermList [ - el])}))))}))) initialState elements - in (Right finalState)) - --- | Interpreter-friendly pure for List terms. -pure :: t0 -> t1 -> Core.Term -> Either t2 Core.Term -pure cx g x = Right (Core.TermList [ - x]) - --- | Interpreter-friendly replicate for List terms. -replicate :: t0 -> t1 -> Core.Term -> Core.Term -> Either t2 Core.Term -replicate cx g n x = - Right (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.lists.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "_"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = x})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.math.range"))), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 1)))})), - Core.applicationArgument = n}))})) - --- | Interpreter-friendly safeHead for List terms. -safeHead :: Context.Context -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -safeHead cx g listTerm = - Eithers.bind (Core_.list cx g listTerm) (\elements -> Right (Logic.ifElse (Lists.null elements) (Core.TermMaybe Nothing) (Core.TermMaybe (Just (Lists.head elements))))) - --- | Interpreter-friendly singleton for List terms. -singleton :: t0 -> t1 -> Core.Term -> Either t2 Core.Term -singleton cx g x = Right (Core.TermList [ - x]) - --- | Interpreter-friendly sort for List terms. -sort :: t0 -> t1 -> Core.Term -> Either t2 Core.Term -sort cx g listTerm = - Right (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.lists.sortOn"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.equality.identity")))})), - Core.applicationArgument = listTerm})) - --- | Interpreter-friendly sortOn for List terms. -sortOn :: Context.Context -> Graph.Graph -> Core.Term -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -sortOn cx g projTerm listTerm = - Eithers.bind (Core_.list cx g listTerm) (\elements -> Right (Lists.foldl (\sorted -> \x -> - let splitResult = - Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.lists.span"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "y"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.equality.lte"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = projTerm, - Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = projTerm, - Core.applicationArgument = x}))}))})))})), - Core.applicationArgument = sorted}) - before = - Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.pairs.first"))), - Core.applicationArgument = splitResult}) - after = - Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.pairs.second"))), - Core.applicationArgument = splitResult}) - in (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.lists.concat2"))), - Core.applicationArgument = before})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.lists.cons"))), - Core.applicationArgument = x})), - Core.applicationArgument = after}))}))) (Core.TermList []) elements)) - --- | Interpreter-friendly span for List terms. -span :: Context.Context -> Graph.Graph -> Core.Term -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -span cx g predTerm listTerm = - Eithers.bind (Core_.list cx g listTerm) (\elements -> - let initialState = - Core.TermPair (Core.TermPair (Core.TermLiteral (Core.LiteralBoolean True), (Core.TermList [])), (Core.TermList [])) - finalState = - Lists.foldl (\acc -> \el -> - let takingLeft = - Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.pairs.first"))), - Core.applicationArgument = acc}) - right = - Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.pairs.second"))), - Core.applicationArgument = acc}) - taking = - Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.pairs.first"))), - Core.applicationArgument = takingLeft}) - left = - Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.pairs.second"))), - Core.applicationArgument = takingLeft}) - in (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.logic.ifElse"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.logic.and"))), - Core.applicationArgument = taking})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = predTerm, - Core.applicationArgument = el}))}))})), - Core.applicationArgument = (Core.TermPair (Core.TermPair (Core.TermLiteral (Core.LiteralBoolean True), (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.lists.concat2"))), - Core.applicationArgument = left})), - Core.applicationArgument = (Core.TermList [ - el])}))), right))})), - Core.applicationArgument = (Core.TermPair (Core.TermPair (Core.TermLiteral (Core.LiteralBoolean False), left), (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.lists.concat2"))), - Core.applicationArgument = right})), - Core.applicationArgument = (Core.TermList [ - el])}))))}))) initialState elements - in (Right (Core.TermPair (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.pairs.second"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.pairs.first"))), - Core.applicationArgument = finalState}))}), (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.pairs.second"))), - Core.applicationArgument = finalState})))))) - --- | Interpreter-friendly zipWith for List terms. -zipWith :: Context.Context -> Graph.Graph -> Core.Term -> Core.Term -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -zipWith cx g funTerm listTerm1 listTerm2 = - Eithers.bind (Core_.list cx g listTerm1) (\elements1 -> Eithers.bind (Core_.list cx g listTerm2) (\elements2 -> Right (Core.TermList (Lists.map (\p -> - let a = Pairs.first p - b = Pairs.second p - in (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = funTerm, - Core.applicationArgument = a})), - Core.applicationArgument = b}))) (Lists.zip elements1 elements2))))) diff --git a/src/gen-main/haskell/Hydra/Eval/Lib/Logic.hs b/src/gen-main/haskell/Hydra/Eval/Lib/Logic.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Eval/Lib/Logic.hs +++ /dev/null @@ -1,46 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Evaluation-level implementations of Logic functions for the Hydra interpreter. - -module Hydra.Eval.Lib.Logic where - -import qualified Hydra.Core as Core -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | Interpreter-friendly logical AND. -and :: t0 -> t1 -> Core.Term -> Core.Term -> Either t2 Core.Term -and cx g a b = - Right (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.logic.ifElse"))), - Core.applicationArgument = a})), - Core.applicationArgument = b})), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralBoolean False))})) - --- | Interpreter-friendly logical NOT. -not :: t0 -> t1 -> Core.Term -> Either t2 Core.Term -not cx g a = - Right (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.logic.ifElse"))), - Core.applicationArgument = a})), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralBoolean False))})), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralBoolean True))})) - --- | Interpreter-friendly logical OR. -or :: t0 -> t1 -> Core.Term -> Core.Term -> Either t2 Core.Term -or cx g a b = - Right (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.logic.ifElse"))), - Core.applicationArgument = a})), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralBoolean True))})), - Core.applicationArgument = b})) diff --git a/src/gen-main/haskell/Hydra/Eval/Lib/Maps.hs b/src/gen-main/haskell/Hydra/Eval/Lib/Maps.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Eval/Lib/Maps.hs +++ /dev/null @@ -1,170 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Evaluation-level implementations of Map functions for the Hydra interpreter. - -module Hydra.Eval.Lib.Maps where - -import qualified Hydra.Context as Context -import qualified Hydra.Core as Core -import qualified Hydra.Errors as Errors -import qualified Hydra.Lib.Lists as Lists -import qualified Hydra.Lib.Maps as Maps -import qualified Hydra.Lib.Pairs as Pairs -import qualified Hydra.Lib.Strings as Strings -import qualified Hydra.Show.Core as Core_ -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | Interpreter-friendly alter for Map terms. -alter :: Context.Context -> t0 -> Core.Term -> Core.Term -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -alter cx g funTerm keyTerm mapTerm = - case mapTerm of - Core.TermMap v0 -> - let currentVal = Maps.lookup keyTerm v0 - newVal = - Core.TermApplication (Core.Application { - Core.applicationFunction = funTerm, - Core.applicationArgument = (Core.TermMaybe currentVal)}) - in (Right (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maybes.maybe"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.delete"))), - Core.applicationArgument = keyTerm})), - Core.applicationArgument = mapTerm}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "newV"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.insert"))), - Core.applicationArgument = keyTerm})), - Core.applicationArgument = (Core.TermVariable (Core.Name "newV"))})), - Core.applicationArgument = mapTerm}))})))})), - Core.applicationArgument = newVal}))) - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "map value") " but found ") (Core_.term mapTerm)))), - Context.inContextContext = cx}) - --- | Interpreter-friendly bimap for Map terms. -bimap :: Context.Context -> t0 -> Core.Term -> Core.Term -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -bimap cx g keyFun valFun mapTerm = - case mapTerm of - Core.TermMap v0 -> - let pairs = Maps.toList v0 - in (Right (Core.TermMap (Maps.fromList (Lists.map (\p -> - let k = Pairs.first p - v = Pairs.second p - in (Core.TermApplication (Core.Application { - Core.applicationFunction = keyFun, - Core.applicationArgument = k}), (Core.TermApplication (Core.Application { - Core.applicationFunction = valFun, - Core.applicationArgument = v})))) pairs)))) - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "map value") " but found ") (Core_.term mapTerm)))), - Context.inContextContext = cx}) - --- | Interpreter-friendly filter for Map terms. -filter :: Context.Context -> t0 -> Core.Term -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -filter cx g valPred mapTerm = - case mapTerm of - Core.TermMap v0 -> - let pairs = Maps.toList v0 - in (Right (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.fromList"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.lists.concat"))), - Core.applicationArgument = (Core.TermList (Lists.map (\p -> - let v = Pairs.second p - in (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.logic.ifElse"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = valPred, - Core.applicationArgument = v}))})), - Core.applicationArgument = (Core.TermList (Lists.pure (Core.TermPair (Pairs.first p, v))))})), - Core.applicationArgument = (Core.TermList [])}))) pairs))}))}))) - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "map value") " but found ") (Core_.term mapTerm)))), - Context.inContextContext = cx}) - --- | Interpreter-friendly filterWithKey for Map terms. -filterWithKey :: Context.Context -> t0 -> Core.Term -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -filterWithKey cx g pred mapTerm = - case mapTerm of - Core.TermMap v0 -> - let pairs = Maps.toList v0 - in (Right (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.fromList"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.lists.concat"))), - Core.applicationArgument = (Core.TermList (Lists.map (\p -> - let k = Pairs.first p - v = Pairs.second p - in (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.logic.ifElse"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = pred, - Core.applicationArgument = k})), - Core.applicationArgument = v}))})), - Core.applicationArgument = (Core.TermList (Lists.pure (Core.TermPair (k, v))))})), - Core.applicationArgument = (Core.TermList [])}))) pairs))}))}))) - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "map value") " but found ") (Core_.term mapTerm)))), - Context.inContextContext = cx}) - --- | Interpreter-friendly findWithDefault for Map terms. -findWithDefault :: t0 -> t1 -> Core.Term -> Core.Term -> Core.Term -> Either t2 Core.Term -findWithDefault cx g defaultTerm keyTerm mapTerm = - Right (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maybes.fromMaybe"))), - Core.applicationArgument = defaultTerm})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.lookup"))), - Core.applicationArgument = keyTerm})), - Core.applicationArgument = mapTerm}))})) - --- | Interpreter-friendly map for Map terms. -map :: Context.Context -> t0 -> Core.Term -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -map cx g valFun mapTerm = - case mapTerm of - Core.TermMap v0 -> - let pairs = Maps.toList v0 - in (Right (Core.TermMap (Maps.fromList (Lists.map (\p -> - let k = Pairs.first p - v = Pairs.second p - in (k, (Core.TermApplication (Core.Application { - Core.applicationFunction = valFun, - Core.applicationArgument = v})))) pairs)))) - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "map value") " but found ") (Core_.term mapTerm)))), - Context.inContextContext = cx}) - --- | Interpreter-friendly mapKeys for Map terms. -mapKeys :: Context.Context -> t0 -> Core.Term -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -mapKeys cx g keyFun mapTerm = - case mapTerm of - Core.TermMap v0 -> - let pairs = Maps.toList v0 - in (Right (Core.TermMap (Maps.fromList (Lists.map (\p -> - let k = Pairs.first p - v = Pairs.second p - in (Core.TermApplication (Core.Application { - Core.applicationFunction = keyFun, - Core.applicationArgument = k}), v)) pairs)))) - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "map value") " but found ") (Core_.term mapTerm)))), - Context.inContextContext = cx}) diff --git a/src/gen-main/haskell/Hydra/Eval/Lib/Math.hs b/src/gen-main/haskell/Hydra/Eval/Lib/Math.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Eval/Lib/Math.hs +++ /dev/null @@ -1,53 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Evaluation-level implementations of Math functions for the Hydra interpreter. - -module Hydra.Eval.Lib.Math where - -import qualified Hydra.Core as Core -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | Interpreter-friendly even. -even :: t0 -> t1 -> Core.Term -> Either t2 Core.Term -even cx g x = - Right (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.equality.equal"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.math.mod"))), - Core.applicationArgument = x})), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 2)))}))})), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 0)))})) - --- | Interpreter-friendly odd. -odd :: t0 -> t1 -> Core.Term -> Either t2 Core.Term -odd cx g x = - Right (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.logic.not"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.math.even"))), - Core.applicationArgument = x}))})) - --- | Interpreter-friendly predecessor. -pred :: t0 -> t1 -> Core.Term -> Either t2 Core.Term -pred cx g x = - Right (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.math.sub"))), - Core.applicationArgument = x})), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 1)))})) - --- | Interpreter-friendly successor. -succ :: t0 -> t1 -> Core.Term -> Either t2 Core.Term -succ cx g x = - Right (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.math.add"))), - Core.applicationArgument = x})), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 1)))})) diff --git a/src/gen-main/haskell/Hydra/Eval/Lib/Maybes.hs b/src/gen-main/haskell/Hydra/Eval/Lib/Maybes.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Eval/Lib/Maybes.hs +++ /dev/null @@ -1,159 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Evaluation-level implementations of Maybe functions for the Hydra interpreter. - -module Hydra.Eval.Lib.Maybes where - -import qualified Hydra.Context as Context -import qualified Hydra.Core as Core -import qualified Hydra.Errors as Errors -import qualified Hydra.Extract.Core as Core_ -import qualified Hydra.Graph as Graph -import qualified Hydra.Lib.Eithers as Eithers -import qualified Hydra.Lib.Lists as Lists -import qualified Hydra.Lib.Maybes as Maybes -import qualified Hydra.Lib.Strings as Strings -import qualified Hydra.Show.Core as Core__ -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | Interpreter-friendly applicative apply for Maybe terms. -apply :: Context.Context -> t0 -> Core.Term -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -apply cx g funOptTerm argOptTerm = - case funOptTerm of - Core.TermMaybe v0 -> case argOptTerm of - Core.TermMaybe v1 -> Right (Core.TermMaybe (Maybes.bind v0 (\f -> Maybes.map (\x -> Core.TermApplication (Core.Application { - Core.applicationFunction = f, - Core.applicationArgument = x})) v1))) - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "optional value") " but found ") (Core__.term argOptTerm)))), - Context.inContextContext = cx}) - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "optional function") " but found ") (Core__.term funOptTerm)))), - Context.inContextContext = cx}) - --- | Interpreter-friendly monadic bind for Maybe terms. -bind :: Context.Context -> t0 -> Core.Term -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -bind cx g optTerm funTerm = - case optTerm of - Core.TermMaybe v0 -> Right (Maybes.maybe (Core.TermMaybe Nothing) (\val -> Core.TermApplication (Core.Application { - Core.applicationFunction = funTerm, - Core.applicationArgument = val})) v0) - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "optional value") " but found ") (Core__.term optTerm)))), - Context.inContextContext = cx}) - --- | Interpreter-friendly case analysis for Maybe terms (cases argument order). -cases :: Context.Context -> t0 -> Core.Term -> Core.Term -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -cases cx g optTerm defaultTerm funTerm = - case optTerm of - Core.TermMaybe v0 -> Right (Maybes.maybe defaultTerm (\val -> Core.TermApplication (Core.Application { - Core.applicationFunction = funTerm, - Core.applicationArgument = val})) v0) - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "optional value") " but found ") (Core__.term optTerm)))), - Context.inContextContext = cx}) - --- | Interpreter-friendly cat for list of Maybe terms. -cat :: Context.Context -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) [Core.Term] -cat cx g listTerm = - Eithers.bind (Core_.list cx g listTerm) (\elements -> Right (Lists.foldl (\acc -> \el -> case el of - Core.TermMaybe v0 -> Maybes.maybe acc (\v -> Lists.concat2 acc (Lists.pure v)) v0 - _ -> acc) [] elements)) - --- | Interpreter-friendly Kleisli composition for Maybe. -compose :: t0 -> t1 -> Core.Term -> Core.Term -> Core.Term -> Either t2 Core.Term -compose cx g funF funG xTerm = - Right (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maybes.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = funF, - Core.applicationArgument = xTerm}))})), - Core.applicationArgument = funG})) - --- | Interpreter-friendly fromJust for Maybe terms. -fromJust :: Context.Context -> t0 -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -fromJust cx g optTerm = - case optTerm of - Core.TermMaybe v0 -> Maybes.maybe (Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "Just value") " but found ") (Core__.term optTerm)))), - Context.inContextContext = cx})) (\val -> Right val) v0 - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "optional value") " but found ") (Core__.term optTerm)))), - Context.inContextContext = cx}) - --- | Interpreter-friendly fromMaybe for Maybe terms. -fromMaybe :: Context.Context -> t0 -> Core.Term -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -fromMaybe cx g defaultTerm optTerm = - case optTerm of - Core.TermMaybe v0 -> Right (Maybes.maybe defaultTerm (\val -> val) v0) - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "optional value") " but found ") (Core__.term optTerm)))), - Context.inContextContext = cx}) - --- | Interpreter-friendly isJust for Maybe terms. -isJust :: Context.Context -> t0 -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -isJust cx g optTerm = - case optTerm of - Core.TermMaybe v0 -> Right (Maybes.maybe (Core.TermLiteral (Core.LiteralBoolean False)) (\_ -> Core.TermLiteral (Core.LiteralBoolean True)) v0) - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "optional value") " but found ") (Core__.term optTerm)))), - Context.inContextContext = cx}) - --- | Interpreter-friendly isNothing for Maybe terms. -isNothing :: Context.Context -> t0 -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -isNothing cx g optTerm = - case optTerm of - Core.TermMaybe v0 -> Right (Maybes.maybe (Core.TermLiteral (Core.LiteralBoolean True)) (\_ -> Core.TermLiteral (Core.LiteralBoolean False)) v0) - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "optional value") " but found ") (Core__.term optTerm)))), - Context.inContextContext = cx}) - --- | Interpreter-friendly map for Maybe terms. -map :: Context.Context -> t0 -> Core.Term -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -map cx g funTerm optTerm = - case optTerm of - Core.TermMaybe v0 -> Right (Core.TermMaybe (Maybes.map (\val -> Core.TermApplication (Core.Application { - Core.applicationFunction = funTerm, - Core.applicationArgument = val})) v0)) - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "optional value") " but found ") (Core__.term optTerm)))), - Context.inContextContext = cx}) - --- | Interpreter-friendly mapMaybe for List terms. -mapMaybe :: Context.Context -> Graph.Graph -> Core.Term -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -mapMaybe cx g funTerm listTerm = - Eithers.bind (Core_.list cx g listTerm) (\elements -> Right (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maybes.cat"))), - Core.applicationArgument = (Core.TermList (Lists.map (\el -> Core.TermApplication (Core.Application { - Core.applicationFunction = funTerm, - Core.applicationArgument = el})) elements))}))) - --- | Interpreter-friendly case analysis for Maybe terms. -maybe :: Context.Context -> t0 -> Core.Term -> Core.Term -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -maybe cx g defaultTerm funTerm optTerm = - case optTerm of - Core.TermMaybe v0 -> Right (Maybes.maybe defaultTerm (\val -> Core.TermApplication (Core.Application { - Core.applicationFunction = funTerm, - Core.applicationArgument = val})) v0) - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "optional value") " but found ") (Core__.term optTerm)))), - Context.inContextContext = cx}) - --- | Interpreter-friendly pure for Maybe terms. -pure :: t0 -> t1 -> Core.Term -> Either t2 Core.Term -pure cx g x = Right (Core.TermMaybe (Just x)) - --- | Interpreter-friendly toList for Maybe terms. -toList :: Context.Context -> t0 -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -toList cx g optTerm = - case optTerm of - Core.TermMaybe v0 -> Right (Core.TermList (Maybes.maybe [] (\val -> Lists.pure val) v0)) - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "optional value") " but found ") (Core__.term optTerm)))), - Context.inContextContext = cx}) diff --git a/src/gen-main/haskell/Hydra/Eval/Lib/Pairs.hs b/src/gen-main/haskell/Hydra/Eval/Lib/Pairs.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Eval/Lib/Pairs.hs +++ /dev/null @@ -1,52 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Evaluation-level implementations of Pair functions for the Hydra interpreter. - -module Hydra.Eval.Lib.Pairs where - -import qualified Hydra.Context as Context -import qualified Hydra.Core as Core -import qualified Hydra.Errors as Errors -import qualified Hydra.Lib.Pairs as Pairs -import qualified Hydra.Lib.Strings as Strings -import qualified Hydra.Show.Core as Core_ -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | Interpreter-friendly bimap for Pair terms. -bimap :: Context.Context -> t0 -> Core.Term -> Core.Term -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -bimap cx g firstFun secondFun pairTerm = - case pairTerm of - Core.TermPair v0 -> - let fst = Pairs.first v0 - snd = Pairs.second v0 - in (Right (Core.TermPair (Core.TermApplication (Core.Application { - Core.applicationFunction = firstFun, - Core.applicationArgument = fst}), (Core.TermApplication (Core.Application { - Core.applicationFunction = secondFun, - Core.applicationArgument = snd}))))) - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "pair value") " but found ") (Core_.term pairTerm)))), - Context.inContextContext = cx}) - --- | Interpreter-friendly first for Pair terms. -first :: Context.Context -> t0 -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -first cx g pairTerm = - case pairTerm of - Core.TermPair v0 -> Right (Pairs.first v0) - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "pair value") " but found ") (Core_.term pairTerm)))), - Context.inContextContext = cx}) - --- | Interpreter-friendly second for Pair terms. -second :: Context.Context -> t0 -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -second cx g pairTerm = - case pairTerm of - Core.TermPair v0 -> Right (Pairs.second v0) - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "pair value") " but found ") (Core_.term pairTerm)))), - Context.inContextContext = cx}) diff --git a/src/gen-main/haskell/Hydra/Eval/Lib/Sets.hs b/src/gen-main/haskell/Hydra/Eval/Lib/Sets.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Eval/Lib/Sets.hs +++ /dev/null @@ -1,85 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Evaluation-level implementations of Set functions for the Hydra interpreter. - -module Hydra.Eval.Lib.Sets where - -import qualified Hydra.Context as Context -import qualified Hydra.Core as Core -import qualified Hydra.Errors as Errors -import qualified Hydra.Extract.Core as Core_ -import qualified Hydra.Graph as Graph -import qualified Hydra.Lib.Eithers as Eithers -import qualified Hydra.Lib.Lists as Lists -import qualified Hydra.Lib.Sets as Sets -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | Interpreter-friendly set difference. -difference :: Context.Context -> Graph.Graph -> Core.Term -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -difference cx g set1Term set2Term = - Eithers.bind (Core_.set cx g set1Term) (\elements -> Right (Lists.foldl (\acc -> \el -> Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.logic.ifElse"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.sets.member"))), - Core.applicationArgument = el})), - Core.applicationArgument = set2Term}))})), - Core.applicationArgument = acc})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.sets.insert"))), - Core.applicationArgument = el})), - Core.applicationArgument = acc}))})) (Core.TermSet (Sets.fromList [])) (Sets.toList elements))) - --- | Interpreter-friendly set intersection. -intersection :: Context.Context -> Graph.Graph -> Core.Term -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -intersection cx g set1Term set2Term = - Eithers.bind (Core_.set cx g set1Term) (\elements -> Right (Lists.foldl (\acc -> \el -> Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.logic.ifElse"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.sets.member"))), - Core.applicationArgument = el})), - Core.applicationArgument = set2Term}))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.sets.insert"))), - Core.applicationArgument = el})), - Core.applicationArgument = acc}))})), - Core.applicationArgument = acc})) (Core.TermSet (Sets.fromList [])) (Sets.toList elements))) - --- | Interpreter-friendly map for Set terms. -map :: Context.Context -> Graph.Graph -> Core.Term -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -map cx g fun setTerm = - Eithers.bind (Core_.set cx g setTerm) (\elements -> Right (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.sets.fromList"))), - Core.applicationArgument = (Core.TermList (Lists.map (\el -> Core.TermApplication (Core.Application { - Core.applicationFunction = fun, - Core.applicationArgument = el})) (Sets.toList elements)))}))) - --- | Interpreter-friendly set union. -union :: Context.Context -> Graph.Graph -> Core.Term -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -union cx g set1Term set2Term = - Eithers.bind (Core_.set cx g set1Term) (\elements -> Right (Lists.foldl (\acc -> \el -> Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.sets.insert"))), - Core.applicationArgument = el})), - Core.applicationArgument = acc})) set2Term (Sets.toList elements))) - --- | Interpreter-friendly unions for list of Set terms. -unions :: Context.Context -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -unions cx g listTerm = - Eithers.bind (Core_.list cx g listTerm) (\elements -> Right (Lists.foldl (\acc -> \s -> Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.sets.union"))), - Core.applicationArgument = acc})), - Core.applicationArgument = s})) (Core.TermSet (Sets.fromList [])) elements)) diff --git a/src/gen-main/haskell/Hydra/Ext/Haskell/Coder.hs b/src/gen-main/haskell/Hydra/Ext/Haskell/Coder.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Ext/Haskell/Coder.hs +++ /dev/null @@ -1,783 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Functions for encoding Hydra modules as Haskell modules - -module Hydra.Ext.Haskell.Coder where - -import qualified Hydra.Adapt as Adapt -import qualified Hydra.Annotations as Annotations -import qualified Hydra.Classes as Classes -import qualified Hydra.Coders as Coders -import qualified Hydra.Constants as Constants -import qualified Hydra.Context as Context -import qualified Hydra.Core as Core -import qualified Hydra.Encode.Core as Core_ -import qualified Hydra.Errors as Errors -import qualified Hydra.Ext.Haskell.Language as Language -import qualified Hydra.Ext.Haskell.Serde as Serde -import qualified Hydra.Ext.Haskell.Syntax as Syntax -import qualified Hydra.Ext.Haskell.Utils as Utils -import qualified Hydra.Formatting as Formatting -import qualified Hydra.Graph as Graph -import qualified Hydra.Lexical as Lexical -import qualified Hydra.Lib.Eithers as Eithers -import qualified Hydra.Lib.Equality as Equality -import qualified Hydra.Lib.Lists as Lists -import qualified Hydra.Lib.Literals as Literals -import qualified Hydra.Lib.Logic as Logic -import qualified Hydra.Lib.Maps as Maps -import qualified Hydra.Lib.Math as Math -import qualified Hydra.Lib.Maybes as Maybes -import qualified Hydra.Lib.Pairs as Pairs -import qualified Hydra.Lib.Sets as Sets -import qualified Hydra.Lib.Strings as Strings -import qualified Hydra.Module as Module -import qualified Hydra.Names as Names -import qualified Hydra.Rewriting as Rewriting -import qualified Hydra.Schemas as Schemas -import qualified Hydra.Serialization as Serialization -import qualified Hydra.Show.Core as Core__ -import qualified Hydra.Util as Util -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | Adapt a Hydra type to Haskell's type system and encode it -adaptTypeToHaskellAndEncode :: Module.Namespaces Syntax.ModuleName -> Core.Type -> Context.Context -> t0 -> Either (Context.InContext Errors.Error) Syntax.Type -adaptTypeToHaskellAndEncode namespaces typ cx g = - - let enc = \t -> encodeType namespaces t cx g - in case (Rewriting.deannotateType typ) of - Core.TypeVariable _ -> enc typ - _ -> Eithers.bind (Eithers.bimap (\_s -> Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError _s)), - Context.inContextContext = cx}) (\_x -> _x) (Adapt.adaptTypeForLanguage Language.haskellLanguage typ)) (\adaptedType -> enc adaptedType) - --- | Generate a constant name for a field (e.g., '_TypeName_fieldName') -constantForFieldName :: Core.Name -> Core.Name -> String -constantForFieldName tname fname = - Strings.cat [ - "_", - (Names.localNameOf tname), - "_", - (Core.unName fname)] - --- | Generate a constant name for a type (e.g., '_TypeName') -constantForTypeName :: Core.Name -> String -constantForTypeName tname = Strings.cat2 "_" (Names.localNameOf tname) - --- | Construct a Haskell module from a Hydra module and its definitions -constructModule :: Module.Namespaces Syntax.ModuleName -> Module.Module -> [Module.Definition] -> Context.Context -> Graph.Graph -> Either (Context.InContext Errors.Error) Syntax.Module -constructModule namespaces mod defs cx g = - - let h = \namespace -> Module.unNamespace namespace - createDeclarations = - \def -> case def of - Module.DefinitionType v0 -> - let name = Module.typeDefinitionName v0 - typ = Module.typeDefinitionType v0 - in (toTypeDeclarationsFrom namespaces name typ cx g) - Module.DefinitionTerm v0 -> Eithers.bind (toDataDeclaration namespaces v0 cx g) (\d -> Right [ - d]) - importName = - \name -> Syntax.ModuleName (Strings.intercalate "." (Lists.map Formatting.capitalize (Strings.splitOn "." name))) - imports = Lists.concat2 domainImports standardImports - domainImports = - - let toImport = - \pair -> - let namespace = Pairs.first pair - alias = Pairs.second pair - name = h namespace - in Syntax.Import { - Syntax.importQualified = True, - Syntax.importModule = (importName name), - Syntax.importAs = (Just alias), - Syntax.importSpec = Nothing} - in (Lists.map toImport (Maps.toList (Module.namespacesMapping namespaces))) - standardImports = - - let toImport = - \triple -> - let name = Pairs.first (Pairs.first triple) - malias = Pairs.second (Pairs.first triple) - hidden = Pairs.second triple - spec = - Logic.ifElse (Lists.null hidden) Nothing (Just (Syntax.SpecImportHiding (Lists.map (\n -> Syntax.ImportExportSpec { - Syntax.importExportSpecModifier = Nothing, - Syntax.importExportSpecName = (Utils.simpleName n), - Syntax.importExportSpecSubspec = Nothing}) hidden))) - in Syntax.Import { - Syntax.importQualified = (Maybes.isJust malias), - Syntax.importModule = (Syntax.ModuleName name), - Syntax.importAs = (Maybes.map (\x -> Syntax.ModuleName x) malias), - Syntax.importSpec = spec} - in (Lists.map toImport (Lists.concat2 [ - (("Prelude", Nothing), [ - "Enum", - "Ordering", - "decodeFloat", - "encodeFloat", - "fail", - "map", - "pure", - "sum"]), - (("Data.ByteString", (Just "B")), []), - (("Data.Int", (Just "I")), []), - (("Data.List", (Just "L")), []), - (("Data.Map", (Just "M")), []), - (("Data.Set", (Just "S")), [])] (Logic.ifElse (Schemas.moduleContainsBinaryLiterals mod) [ - (("Hydra.Lib.Literals", (Just "Literals")), [])] []))) - in (Eithers.bind (Eithers.mapList createDeclarations defs) (\declLists -> - let decls = Lists.concat declLists - mc = Module.moduleDescription mod - in (Right (Syntax.Module { - Syntax.moduleHead = (Just (Syntax.ModuleHead { - Syntax.moduleHeadComments = mc, - Syntax.moduleHeadName = (importName (h (Module.moduleNamespace mod))), - Syntax.moduleHeadExports = []})), - Syntax.moduleImports = imports, - Syntax.moduleDeclarations = decls})))) - --- | Encode a Hydra case statement as a Haskell case expression with a given scrutinee -encodeCaseExpression :: Int -> Module.Namespaces Syntax.ModuleName -> Core.CaseStatement -> Syntax.Expression -> Context.Context -> Graph.Graph -> Either (Context.InContext Errors.Error) Syntax.Expression -encodeCaseExpression depth namespaces stmt scrutinee cx g = - - let dn = Core.caseStatementTypeName stmt - def = Core.caseStatementDefault stmt - fields = Core.caseStatementCases stmt - toAlt = - \fieldMap -> \field -> - let fn = Core.fieldName field - fun_ = Core.fieldTerm field - v0 = Strings.cat2 "v" (Literals.showInt32 depth) - raw = - Core.TermApplication (Core.Application { - Core.applicationFunction = fun_, - Core.applicationArgument = (Core.TermVariable (Core.Name v0))}) - rhsTerm = Rewriting.simplifyTerm raw - v1 = Logic.ifElse (Rewriting.isFreeVariableInTerm (Core.Name v0) rhsTerm) Constants.ignoredVariable v0 - hname = - Utils.unionFieldReference (Sets.union (Sets.fromList (Maps.keys (Graph.graphBoundTerms g))) (Sets.fromList (Maps.keys (Graph.graphSchemaTypes g)))) namespaces dn fn - in (Eithers.bind (Maybes.cases (Maps.lookup fn fieldMap) (Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat [ - "field ", - (Literals.showString (Core.unName fn)), - " not found in ", - (Literals.showString (Core.unName dn))]))), - Context.inContextContext = cx})) (\fieldType -> - let ft = Core.fieldTypeType fieldType - noArgs = [] - singleArg = [ - Syntax.PatternName (Utils.rawName v1)] - in case (Rewriting.deannotateType ft) of - Core.TypeUnit -> Right noArgs - _ -> Right singleArg)) (\args -> - let lhs = Utils.applicationPattern hname args - in (Eithers.bind (Eithers.map (\x -> Syntax.CaseRhs x) (encodeTerm (Math.add depth 1) namespaces rhsTerm cx g)) (\rhs -> Right (Syntax.Alternative { - Syntax.alternativePattern = lhs, - Syntax.alternativeRhs = rhs, - Syntax.alternativeBinds = Nothing}))))) - in (Eithers.bind (Schemas.requireUnionType cx g dn) (\rt -> - let toFieldMapEntry = \f -> (Core.fieldTypeName f, f) - fieldMap = Maps.fromList (Lists.map toFieldMapEntry rt) - in (Eithers.bind (Eithers.mapList (toAlt fieldMap) fields) (\ecases -> Eithers.bind (Maybes.cases def (Right []) (\d -> Eithers.bind (Eithers.map (\x -> Syntax.CaseRhs x) (encodeTerm depth namespaces d cx g)) (\cs -> - let lhs = Syntax.PatternName (Utils.rawName Constants.ignoredVariable) - alt = - Syntax.Alternative { - Syntax.alternativePattern = lhs, - Syntax.alternativeRhs = cs, - Syntax.alternativeBinds = Nothing} - in (Right [ - alt])))) (\dcases -> Right (Syntax.ExpressionCase (Syntax.CaseExpression { - Syntax.caseExpressionCase = scrutinee, - Syntax.caseExpressionAlternatives = (Lists.concat2 ecases dcases)}))))))) - --- | Encode a Hydra function as a Haskell expression -encodeFunction :: Int -> Module.Namespaces Syntax.ModuleName -> Core.Function -> Context.Context -> Graph.Graph -> Either (Context.InContext Errors.Error) Syntax.Expression -encodeFunction depth namespaces fun cx g = - case fun of - Core.FunctionElimination v0 -> case v0 of - Core.EliminationWrap v1 -> Right (Syntax.ExpressionVariable (Utils.elementReference namespaces (Names.qname (Maybes.fromJust (Names.namespaceOf v1)) (Utils.newtypeAccessorName v1)))) - Core.EliminationRecord v1 -> - let dn = Core.projectionTypeName v1 - fname = Core.projectionField v1 - in (Right (Syntax.ExpressionVariable (Utils.recordFieldReference namespaces dn fname))) - Core.EliminationUnion v1 -> Eithers.map (Utils.hslambda (Utils.rawName "x")) (encodeCaseExpression depth namespaces v1 (Utils.hsvar "x") cx g) - Core.FunctionLambda v0 -> - let v = Core.lambdaParameter v0 - body = Core.lambdaBody v0 - in (Eithers.bind (encodeTerm depth namespaces body cx g) (\hbody -> Right (Utils.hslambda (Utils.elementReference namespaces v) hbody))) - Core.FunctionPrimitive v0 -> Right (Syntax.ExpressionVariable (Utils.elementReference namespaces v0)) - --- | Encode a Hydra literal as a Haskell expression -encodeLiteral :: Core.Literal -> Context.Context -> Either (Context.InContext Errors.Error) Syntax.Expression -encodeLiteral l cx = - case l of - Core.LiteralBinary v0 -> Right (Utils.hsapp (Utils.hsvar "Literals.stringToBinary") (Utils.hslit (Syntax.LiteralString (Literals.binaryToString v0)))) - Core.LiteralBoolean v0 -> Right (Utils.hsvar (Logic.ifElse v0 "True" "False")) - Core.LiteralFloat v0 -> case v0 of - Core.FloatValueFloat32 v1 -> Right (Utils.hslit (Syntax.LiteralFloat v1)) - Core.FloatValueFloat64 v1 -> Right (Utils.hslit (Syntax.LiteralDouble v1)) - Core.FloatValueBigfloat v1 -> Right (Utils.hslit (Syntax.LiteralDouble (Literals.bigfloatToFloat64 v1))) - Core.LiteralInteger v0 -> case v0 of - Core.IntegerValueBigint v1 -> Right (Utils.hslit (Syntax.LiteralInteger v1)) - Core.IntegerValueInt8 v1 -> Right (Utils.hslit (Syntax.LiteralInteger (Literals.int8ToBigint v1))) - Core.IntegerValueInt16 v1 -> Right (Utils.hslit (Syntax.LiteralInteger (Literals.int16ToBigint v1))) - Core.IntegerValueInt32 v1 -> Right (Utils.hslit (Syntax.LiteralInt v1)) - Core.IntegerValueInt64 v1 -> Right (Utils.hslit (Syntax.LiteralInteger (Literals.int64ToBigint v1))) - Core.IntegerValueUint8 v1 -> Right (Utils.hslit (Syntax.LiteralInteger (Literals.uint8ToBigint v1))) - Core.IntegerValueUint16 v1 -> Right (Utils.hslit (Syntax.LiteralInteger (Literals.uint16ToBigint v1))) - Core.IntegerValueUint32 v1 -> Right (Utils.hslit (Syntax.LiteralInteger (Literals.uint32ToBigint v1))) - Core.IntegerValueUint64 v1 -> Right (Utils.hslit (Syntax.LiteralInteger (Literals.uint64ToBigint v1))) - Core.LiteralString v0 -> Right (Utils.hslit (Syntax.LiteralString v0)) - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 "literal value " (Core__.literal l)))), - Context.inContextContext = cx}) - --- | Encode a Hydra term as a Haskell expression -encodeTerm :: Int -> Module.Namespaces Syntax.ModuleName -> Core.Term -> Context.Context -> Graph.Graph -> Either (Context.InContext Errors.Error) Syntax.Expression -encodeTerm depth namespaces term cx g = - - let encode = \t -> encodeTerm depth namespaces t cx g - nonemptyMap = - \m -> - let lhs = Utils.hsvar "M.fromList" - encodePair = - \pair -> - let k = Pairs.first pair - v = Pairs.second pair - in (Eithers.bind (encode k) (\hk -> Eithers.bind (encode v) (\hv -> Right (Syntax.ExpressionTuple [ - hk, - hv])))) - in (Eithers.bind (Eithers.map (\x -> Syntax.ExpressionList x) (Eithers.mapList encodePair (Maps.toList m))) (\rhs -> Right (Utils.hsapp lhs rhs))) - nonemptySet = - \s -> - let lhs = Utils.hsvar "S.fromList" - in (Eithers.bind (encodeTerm depth namespaces (Core.TermList (Sets.toList s)) cx g) (\rhs -> Right (Utils.hsapp lhs rhs))) - in case (Rewriting.deannotateTerm term) of - Core.TermApplication v0 -> - let fun = Core.applicationFunction v0 - arg = Core.applicationArgument v0 - deannotatedFun = Rewriting.deannotateTerm fun - in case deannotatedFun of - Core.TermFunction v1 -> case v1 of - Core.FunctionElimination v2 -> case v2 of - Core.EliminationUnion v3 -> Eithers.bind (encode arg) (\harg -> encodeCaseExpression depth namespaces v3 harg cx g) - _ -> Eithers.bind (encode fun) (\hfun -> Eithers.bind (encode arg) (\harg -> Right (Utils.hsapp hfun harg))) - _ -> Eithers.bind (encode fun) (\hfun -> Eithers.bind (encode arg) (\harg -> Right (Utils.hsapp hfun harg))) - _ -> Eithers.bind (encode fun) (\hfun -> Eithers.bind (encode arg) (\harg -> Right (Utils.hsapp hfun harg))) - Core.TermEither v0 -> Eithers.either (\l -> Eithers.bind (encode l) (\hl -> Right (Utils.hsapp (Utils.hsvar "Left") hl))) (\r -> Eithers.bind (encode r) (\hr -> Right (Utils.hsapp (Utils.hsvar "Right") hr))) v0 - Core.TermFunction v0 -> encodeFunction depth namespaces v0 cx g - Core.TermLet v0 -> - let collectBindings = - \lt -> - let bs = Core.letBindings lt - body = Core.letBody lt - in case (Rewriting.deannotateTerm body) of - Core.TermLet v1 -> - let innerResult = collectBindings v1 - in (Lists.concat2 bs (Pairs.first innerResult), (Pairs.second innerResult)) - _ -> (bs, body) - collected = collectBindings v0 - allBindings = Pairs.first collected - finalBody = Pairs.second collected - encodeBinding = - \binding -> - let name = Core.bindingName binding - term_ = Core.bindingTerm binding - hname = Utils.simpleName (Core.unName name) - in (Eithers.bind (encode term_) (\hexpr -> Right (Syntax.LocalBindingValue (Utils.simpleValueBinding hname hexpr Nothing)))) - in (Eithers.bind (Eithers.mapList encodeBinding allBindings) (\hbindings -> Eithers.bind (encode finalBody) (\hinner -> Right (Syntax.ExpressionLet (Syntax.LetExpression { - Syntax.letExpressionBindings = hbindings, - Syntax.letExpressionInner = hinner}))))) - Core.TermList v0 -> Eithers.bind (Eithers.mapList encode v0) (\helems -> Right (Syntax.ExpressionList helems)) - Core.TermLiteral v0 -> encodeLiteral v0 cx - Core.TermMap v0 -> Logic.ifElse (Maps.null v0) (Right (Utils.hsvar "M.empty")) (nonemptyMap v0) - Core.TermMaybe v0 -> Maybes.cases v0 (Right (Utils.hsvar "Nothing")) (\t -> Eithers.bind (encode t) (\ht -> Right (Utils.hsapp (Utils.hsvar "Just") ht))) - Core.TermPair v0 -> Eithers.bind (encode (Pairs.first v0)) (\f -> Eithers.bind (encode (Pairs.second v0)) (\s -> Right (Syntax.ExpressionTuple [ - f, - s]))) - Core.TermRecord v0 -> - let sname = Core.recordTypeName v0 - fields = Core.recordFields v0 - toFieldUpdate = - \field -> - let fn = Core.fieldName field - ft = Core.fieldTerm field - fieldRef = Utils.recordFieldReference namespaces sname fn - in (Eithers.bind (encode ft) (\hft -> Right (Syntax.FieldUpdate { - Syntax.fieldUpdateName = fieldRef, - Syntax.fieldUpdateValue = hft}))) - typeName = Utils.elementReference namespaces sname - in (Eithers.bind (Eithers.mapList toFieldUpdate fields) (\updates -> Right (Syntax.ExpressionConstructRecord (Syntax.ConstructRecordExpression { - Syntax.constructRecordExpressionName = typeName, - Syntax.constructRecordExpressionFields = updates})))) - Core.TermSet v0 -> Logic.ifElse (Sets.null v0) (Right (Utils.hsvar "S.empty")) (nonemptySet v0) - Core.TermTypeLambda v0 -> - let term1 = Core.typeLambdaBody v0 - in (encode term1) - Core.TermTypeApplication v0 -> - let term1 = Core.typeApplicationTermBody v0 - in (encode term1) - Core.TermUnion v0 -> - let sname = Core.injectionTypeName v0 - field = Core.injectionField v0 - fn = Core.fieldName field - ft = Core.fieldTerm field - lhs = - Syntax.ExpressionVariable (Utils.unionFieldReference (Sets.union (Sets.fromList (Maps.keys (Graph.graphBoundTerms g))) (Sets.fromList (Maps.keys (Graph.graphSchemaTypes g)))) namespaces sname fn) - dflt = Eithers.map (Utils.hsapp lhs) (encode ft) - in (Eithers.bind (Schemas.requireUnionField cx g sname fn) (\ftyp -> case (Rewriting.deannotateType ftyp) of - Core.TypeUnit -> Right lhs - _ -> dflt)) - Core.TermUnit -> Right (Syntax.ExpressionTuple []) - Core.TermVariable v0 -> Right (Syntax.ExpressionVariable (Utils.elementReference namespaces v0)) - Core.TermWrap v0 -> - let tname = Core.wrappedTermTypeName v0 - term_ = Core.wrappedTermBody v0 - lhs = Syntax.ExpressionVariable (Utils.elementReference namespaces tname) - in (Eithers.bind (encode term_) (\rhs -> Right (Utils.hsapp lhs rhs))) - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 "unexpected term: " (Core__.term term)))), - Context.inContextContext = cx}) - --- | Encode a Hydra type as a Haskell type -encodeType :: Module.Namespaces Syntax.ModuleName -> Core.Type -> Context.Context -> t0 -> Either (Context.InContext Errors.Error) Syntax.Type -encodeType namespaces typ cx g = - - let encode = \t -> encodeType namespaces t cx g - ref = \name -> Right (Syntax.TypeVariable (Utils.elementReference namespaces name)) - unitTuple = Syntax.TypeTuple [] - in case (Rewriting.deannotateType typ) of - Core.TypeApplication v0 -> - let lhs = Core.applicationTypeFunction v0 - rhs = Core.applicationTypeArgument v0 - in (Eithers.bind (encode lhs) (\hlhs -> Eithers.bind (encode rhs) (\hrhs -> Right (Utils.toTypeApplication [ - hlhs, - hrhs])))) - Core.TypeEither v0 -> - let left_ = Core.eitherTypeLeft v0 - right_ = Core.eitherTypeRight v0 - in (Eithers.bind (encode left_) (\hleft -> Eithers.bind (encode right_) (\hright -> Right (Utils.toTypeApplication [ - Syntax.TypeVariable (Utils.rawName "Either"), - hleft, - hright])))) - Core.TypeFunction v0 -> - let dom = Core.functionTypeDomain v0 - cod = Core.functionTypeCodomain v0 - in (Eithers.bind (encode dom) (\hdom -> Eithers.bind (encode cod) (\hcod -> Right (Syntax.TypeFunction (Syntax.FunctionType { - Syntax.functionTypeDomain = hdom, - Syntax.functionTypeCodomain = hcod}))))) - Core.TypeForall v0 -> - let v = Core.forallTypeParameter v0 - body = Core.forallTypeBody v0 - in (encode body) - Core.TypeList v0 -> Eithers.bind (encode v0) (\hlt -> Right (Syntax.TypeList hlt)) - Core.TypeLiteral v0 -> case v0 of - Core.LiteralTypeBinary -> Right (Syntax.TypeVariable (Utils.rawName "B.ByteString")) - Core.LiteralTypeBoolean -> Right (Syntax.TypeVariable (Utils.rawName "Bool")) - Core.LiteralTypeFloat v1 -> case v1 of - Core.FloatTypeFloat32 -> Right (Syntax.TypeVariable (Utils.rawName "Float")) - Core.FloatTypeFloat64 -> Right (Syntax.TypeVariable (Utils.rawName "Double")) - Core.FloatTypeBigfloat -> Right (Syntax.TypeVariable (Utils.rawName "Double")) - Core.LiteralTypeInteger v1 -> case v1 of - Core.IntegerTypeBigint -> Right (Syntax.TypeVariable (Utils.rawName "Integer")) - Core.IntegerTypeInt8 -> Right (Syntax.TypeVariable (Utils.rawName "I.Int8")) - Core.IntegerTypeInt16 -> Right (Syntax.TypeVariable (Utils.rawName "I.Int16")) - Core.IntegerTypeInt32 -> Right (Syntax.TypeVariable (Utils.rawName "Int")) - Core.IntegerTypeInt64 -> Right (Syntax.TypeVariable (Utils.rawName "I.Int64")) - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 "unexpected integer type: " (Core__.integerType v1)))), - Context.inContextContext = cx}) - Core.LiteralTypeString -> Right (Syntax.TypeVariable (Utils.rawName "String")) - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 "unexpected literal type: " (Core__.literalType v0)))), - Context.inContextContext = cx}) - Core.TypeMap v0 -> - let kt = Core.mapTypeKeys v0 - vt = Core.mapTypeValues v0 - in (Eithers.bind (encode kt) (\hkt -> Eithers.bind (encode vt) (\hvt -> Right (Utils.toTypeApplication [ - Syntax.TypeVariable (Utils.rawName "M.Map"), - hkt, - hvt])))) - Core.TypeMaybe v0 -> Eithers.bind (encode v0) (\hot -> Right (Utils.toTypeApplication [ - Syntax.TypeVariable (Utils.rawName "Maybe"), - hot])) - Core.TypePair v0 -> Eithers.bind (encode (Core.pairTypeFirst v0)) (\f -> Eithers.bind (encode (Core.pairTypeSecond v0)) (\s -> Right (Syntax.TypeTuple [ - f, - s]))) - Core.TypeRecord _ -> ref (Core.Name "placeholder") - Core.TypeSet v0 -> Eithers.bind (encode v0) (\hst -> Right (Utils.toTypeApplication [ - Syntax.TypeVariable (Utils.rawName "S.Set"), - hst])) - Core.TypeUnion _ -> ref (Core.Name "placeholder") - Core.TypeUnit -> Right unitTuple - Core.TypeVariable v0 -> ref v0 - Core.TypeVoid -> Right (Syntax.TypeVariable (Utils.rawName "Void")) - Core.TypeWrap _ -> ref (Core.Name "placeholder") - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 "unexpected type: " (Core__.type_ typ)))), - Context.inContextContext = cx}) - --- | Encode a Hydra type as a Haskell type with typeclass assertions -encodeTypeWithClassAssertions :: Module.Namespaces Syntax.ModuleName -> M.Map Core.Name (S.Set Classes.TypeClass) -> Core.Type -> Context.Context -> t0 -> Either (Context.InContext Errors.Error) Syntax.Type -encodeTypeWithClassAssertions namespaces explicitClasses typ cx g = - - let classes = Maps.union explicitClasses (getImplicitTypeClasses typ) - implicitClasses = getImplicitTypeClasses typ - encodeAssertion = - \pair -> - let name = Pairs.first pair - cls = Pairs.second pair - hname = - Utils.rawName (case cls of - Classes.TypeClassEquality -> "Eq" - Classes.TypeClassOrdering -> "Ord") - htype = Syntax.TypeVariable (Utils.rawName (Core.unName name)) - in (Syntax.AssertionClass (Syntax.ClassAssertion { - Syntax.classAssertionName = hname, - Syntax.classAssertionTypes = [ - htype]})) - assertPairs = Lists.concat (Lists.map toPairs (Maps.toList classes)) - toPairs = - \mapEntry -> - let name = Pairs.first mapEntry - clsSet = Pairs.second mapEntry - toPair = \c -> (name, c) - in (Lists.map toPair (Sets.toList clsSet)) - in (Eithers.bind (adaptTypeToHaskellAndEncode namespaces typ cx g) (\htyp -> Logic.ifElse (Lists.null assertPairs) (Right htyp) ( - let encoded = Lists.map encodeAssertion assertPairs - hassert = Logic.ifElse (Equality.equal (Lists.length encoded) 1) (Lists.head encoded) (Syntax.AssertionTuple encoded) - in (Right (Syntax.TypeCtx (Syntax.ContextType { - Syntax.contextTypeCtx = hassert, - Syntax.contextTypeType = htyp})))))) - --- | Find type variables that require an Ord constraint (used in maps or sets) -findOrdVariables :: Core.Type -> S.Set Core.Name -findOrdVariables typ = - - let fold = - \names -> \typ_ -> case typ_ of - Core.TypeMap v0 -> - let kt = Core.mapTypeKeys v0 - in (tryType names kt) - Core.TypeSet v0 -> tryType names v0 - _ -> names - isTypeVariable = \v -> Maybes.isNothing (Names.namespaceOf v) - tryType = - \names -> \t -> case (Rewriting.deannotateType t) of - Core.TypeVariable v0 -> Logic.ifElse (isTypeVariable v0) (Sets.insert v0 names) names - _ -> names - in (Rewriting.foldOverType Coders.TraversalOrderPre fold Sets.empty typ) - --- | Get implicit typeclass constraints for type variables that need Ord -getImplicitTypeClasses :: Core.Type -> M.Map Core.Name (S.Set Classes.TypeClass) -getImplicitTypeClasses typ = - - let toPair = \name -> (name, (Sets.fromList [ - Classes.TypeClassOrdering])) - in (Maps.fromList (Lists.map toPair (Sets.toList (findOrdVariables typ)))) - --- | Whether to include type definitions in generated Haskell modules -includeTypeDefinitions :: Bool -includeTypeDefinitions = False - --- | The key used to track Haskell variable depth in annotations -keyHaskellVar :: Core.Name -keyHaskellVar = Core.Name "haskellVar" - --- | Convert a Hydra module to Haskell source code as a filepath-to-content map -moduleToHaskell :: Module.Module -> [Module.Definition] -> Context.Context -> Graph.Graph -> Either (Context.InContext Errors.Error) (M.Map String String) -moduleToHaskell mod defs cx g = - Eithers.bind (moduleToHaskellModule mod defs cx g) (\hsmod -> - let s = Serialization.printExpr (Serialization.parenthesize (Serde.moduleToExpr hsmod)) - filepath = Names.namespaceToFilePath Util.CaseConventionPascal (Module.FileExtension "hs") (Module.moduleNamespace mod) - in (Right (Maps.singleton filepath s))) - --- | Convert a Hydra module and definitions to a Haskell module AST -moduleToHaskellModule :: Module.Module -> [Module.Definition] -> Context.Context -> Graph.Graph -> Either (Context.InContext Errors.Error) Syntax.Module -moduleToHaskellModule mod defs cx g = - Eithers.bind (Utils.namespacesForModule mod cx g) (\namespaces -> constructModule namespaces mod defs cx g) - --- | Generate Haskell declarations for type and field name constants -nameDecls :: Module.Namespaces Syntax.ModuleName -> Core.Name -> Core.Type -> [Syntax.DeclarationWithComments] -nameDecls namespaces name typ = - - let nm = Core.unName name - toDecl = - \n -> \pair -> - let k = Pairs.first pair - v = Pairs.second pair - decl = - Syntax.DeclarationValueBinding (Syntax.ValueBindingSimple (Syntax.SimpleValueBinding { - Syntax.simpleValueBindingPattern = (Utils.applicationPattern (Utils.simpleName k) []), - Syntax.simpleValueBindingRhs = (Syntax.RightHandSide (Syntax.ExpressionApplication (Syntax.ApplicationExpression { - Syntax.applicationExpressionFunction = (Syntax.ExpressionVariable (Utils.elementReference namespaces n)), - Syntax.applicationExpressionArgument = (Syntax.ExpressionLiteral (Syntax.LiteralString v))}))), - Syntax.simpleValueBindingLocalBindings = Nothing})) - in Syntax.DeclarationWithComments { - Syntax.declarationWithCommentsBody = decl, - Syntax.declarationWithCommentsComments = Nothing} - nameDecl = (constantForTypeName name, nm) - fieldDecls = Lists.map toConstant (Lexical.fieldsOf typ) - toConstant = - \fieldType -> - let fname = Core.fieldTypeName fieldType - in (constantForFieldName name fname, (Core.unName fname)) - in (Logic.ifElse useCoreImport (Lists.cons (toDecl (Core.Name "hydra.core.Name") nameDecl) (Lists.map (toDecl (Core.Name "hydra.core.Name")) fieldDecls)) []) - --- | Convert a Hydra term definition to a Haskell declaration with comments -toDataDeclaration :: Module.Namespaces Syntax.ModuleName -> Module.TermDefinition -> Context.Context -> Graph.Graph -> Either (Context.InContext Errors.Error) Syntax.DeclarationWithComments -toDataDeclaration namespaces def cx g = - - let name = Module.termDefinitionName def - term = Module.termDefinitionTerm def - typ = Module.termDefinitionType def - hname = Utils.simpleName (Names.localNameOf name) - rewriteValueBinding = - \vb -> case vb of - Syntax.ValueBindingSimple v0 -> - let pattern_ = Syntax.simpleValueBindingPattern v0 - rhs = Syntax.simpleValueBindingRhs v0 - bindings = Syntax.simpleValueBindingLocalBindings v0 - in case pattern_ of - Syntax.PatternApplication v1 -> - let name_ = Syntax.applicationPatternName v1 - args = Syntax.applicationPatternArgs v1 - rhsExpr = Syntax.unRightHandSide rhs - in case rhsExpr of - Syntax.ExpressionLambda v2 -> - let vars = Syntax.lambdaExpressionBindings v2 - body = Syntax.lambdaExpressionInner v2 - newPattern = Utils.applicationPattern name_ (Lists.concat2 args vars) - newRhs = Syntax.RightHandSide body - in (rewriteValueBinding (Syntax.ValueBindingSimple (Syntax.SimpleValueBinding { - Syntax.simpleValueBindingPattern = newPattern, - Syntax.simpleValueBindingRhs = newRhs, - Syntax.simpleValueBindingLocalBindings = bindings}))) - _ -> vb - _ -> vb - toDecl = - \comments -> \hname_ -> \term_ -> \bindings -> case (Rewriting.deannotateTerm term_) of - Core.TermLet v0 -> - let lbindings = Core.letBindings v0 - env = Core.letBody v0 - toTermDefinition = \hname_ -> \hterm_ -> Syntax.LocalBindingValue (Utils.simpleValueBinding hname_ hterm_ Nothing) - hnames = Lists.map (\binding -> Utils.simpleName (Core.unName (Core.bindingName binding))) lbindings - terms = Lists.map Core.bindingTerm lbindings - in (Eithers.bind (Eithers.mapList (\t -> encodeTerm 0 namespaces t cx g) terms) (\hterms -> - let hbindings = Lists.zipWith toTermDefinition hnames hterms - prevBindings = Maybes.maybe [] (\lb -> Syntax.unLocalBindings lb) bindings - allBindings = Lists.concat2 prevBindings hbindings - in (toDecl comments hname_ env (Just (Syntax.LocalBindings allBindings))))) - _ -> Eithers.bind (encodeTerm 0 namespaces term_ cx g) (\hterm -> - let vb = Utils.simpleValueBinding hname_ hterm bindings - schemeConstraints = Maybes.maybe Nothing (\ts -> Core.typeSchemeConstraints ts) typ - schemeClasses = typeSchemeConstraintsToClassMap schemeConstraints - in (Eithers.bind (Annotations.getTypeClasses cx g (Rewriting.removeTypesFromTerm term)) (\explicitClasses -> - let combinedClasses = Maps.union schemeClasses explicitClasses - schemeType = Maybes.maybe Core.TypeUnit (\ts -> Core.typeSchemeType ts) typ - in (Eithers.bind (encodeTypeWithClassAssertions namespaces combinedClasses schemeType cx g) (\htype -> - let decl = - Syntax.DeclarationTypedBinding (Syntax.TypedBinding { - Syntax.typedBindingTypeSignature = Syntax.TypeSignature { - Syntax.typeSignatureName = hname_, - Syntax.typeSignatureType = htype}, - Syntax.typedBindingValueBinding = (rewriteValueBinding vb)}) - in (Right (Syntax.DeclarationWithComments { - Syntax.declarationWithCommentsBody = decl, - Syntax.declarationWithCommentsComments = comments}))))))) - in (Eithers.bind (Annotations.getTermDescription cx g term) (\comments -> toDecl comments hname term Nothing)) - --- | Convert a Hydra type definition to Haskell declarations -toTypeDeclarationsFrom :: Module.Namespaces Syntax.ModuleName -> Core.Name -> Core.Type -> Context.Context -> Graph.Graph -> Either (Context.InContext Errors.Error) [Syntax.DeclarationWithComments] -toTypeDeclarationsFrom namespaces elementName typ cx g = - - let lname = Names.localNameOf elementName - hname = Utils.simpleName lname - declHead = - \name -> \vars_ -> Logic.ifElse (Lists.null vars_) (Syntax.DeclarationHeadSimple name) ( - let h = Lists.head vars_ - rest = Lists.tail vars_ - hvar = Syntax.Variable (Utils.simpleName (Core.unName h)) - in (Syntax.DeclarationHeadApplication (Syntax.ApplicationDeclarationHead { - Syntax.applicationDeclarationHeadFunction = (declHead name rest), - Syntax.applicationDeclarationHeadOperand = hvar}))) - newtypeCons = - \tname -> \typ_ -> - let hname0 = Utils.simpleName (Utils.newtypeAccessorName tname) - in (Eithers.bind (adaptTypeToHaskellAndEncode namespaces typ_ cx g) (\htype -> - let hfield = - Syntax.FieldWithComments { - Syntax.fieldWithCommentsField = Syntax.Field { - Syntax.fieldName = hname0, - Syntax.fieldType = htype}, - Syntax.fieldWithCommentsComments = Nothing} - constructorName = Utils.simpleName (Names.localNameOf tname) - in (Right (Syntax.ConstructorWithComments { - Syntax.constructorWithCommentsBody = (Syntax.ConstructorRecord (Syntax.RecordConstructor { - Syntax.recordConstructorName = constructorName, - Syntax.recordConstructorFields = [ - hfield]})), - Syntax.constructorWithCommentsComments = Nothing})))) - recordCons = - \lname_ -> \fields -> - let toField = - \fieldType -> - let fname = Core.fieldTypeName fieldType - ftype = Core.fieldTypeType fieldType - hname_ = Utils.simpleName (Strings.cat2 (Formatting.decapitalize lname_) (Formatting.capitalize (Core.unName fname))) - in (Eithers.bind (adaptTypeToHaskellAndEncode namespaces ftype cx g) (\htype -> Eithers.bind (Annotations.getTypeDescription cx g ftype) (\comments -> Right (Syntax.FieldWithComments { - Syntax.fieldWithCommentsField = Syntax.Field { - Syntax.fieldName = hname_, - Syntax.fieldType = htype}, - Syntax.fieldWithCommentsComments = comments})))) - in (Eithers.bind (Eithers.mapList toField fields) (\hFields -> Right (Syntax.ConstructorWithComments { - Syntax.constructorWithCommentsBody = (Syntax.ConstructorRecord (Syntax.RecordConstructor { - Syntax.recordConstructorName = (Utils.simpleName lname_), - Syntax.recordConstructorFields = hFields})), - Syntax.constructorWithCommentsComments = Nothing}))) - unionCons = - \boundNames_ -> \lname_ -> \fieldType -> - let fname = Core.fieldTypeName fieldType - ftype = Core.fieldTypeType fieldType - deconflict = - \name -> - let tname = - Names.unqualifyName (Module.QualifiedName { - Module.qualifiedNameNamespace = (Just (Pairs.first (Module.namespacesFocus namespaces))), - Module.qualifiedNameLocal = name}) - in (Logic.ifElse (Sets.member tname boundNames_) (deconflict (Strings.cat2 name "_")) name) - in (Eithers.bind (Annotations.getTypeDescription cx g ftype) (\comments -> - let nm = deconflict (Strings.cat2 (Formatting.capitalize lname_) (Formatting.capitalize (Core.unName fname))) - in (Eithers.bind (Logic.ifElse (Equality.equal (Rewriting.deannotateType ftype) Core.TypeUnit) (Right []) (Eithers.bind (adaptTypeToHaskellAndEncode namespaces ftype cx g) (\htype -> Right [ - htype]))) (\typeList -> Right (Syntax.ConstructorWithComments { - Syntax.constructorWithCommentsBody = (Syntax.ConstructorOrdinary (Syntax.OrdinaryConstructor { - Syntax.ordinaryConstructorName = (Utils.simpleName nm), - Syntax.ordinaryConstructorFields = typeList})), - Syntax.constructorWithCommentsComments = comments}))))) - in (Eithers.bind (Schemas.isSerializableByName cx g elementName) (\isSer -> - let deriv = - Syntax.Deriving (Logic.ifElse isSer (Lists.map Utils.rawName [ - "Eq", - "Ord", - "Read", - "Show"]) []) - unpackResult = Utils.unpackForallType typ - vars = Pairs.first unpackResult - t_ = Pairs.second unpackResult - hd = declHead hname (Lists.reverse vars) - in (Eithers.bind (case (Rewriting.deannotateType t_) of - Core.TypeRecord v0 -> Eithers.bind (recordCons lname v0) (\cons -> Right (Syntax.DeclarationData (Syntax.DataDeclaration { - Syntax.dataDeclarationKeyword = Syntax.DataOrNewtypeData, - Syntax.dataDeclarationContext = [], - Syntax.dataDeclarationHead = hd, - Syntax.dataDeclarationConstructors = [ - cons], - Syntax.dataDeclarationDeriving = [ - deriv]}))) - Core.TypeUnion v0 -> Eithers.bind (Eithers.mapList (unionCons (Sets.fromList (Maps.keys (Graph.graphBoundTerms g))) lname) v0) (\cons -> Right (Syntax.DeclarationData (Syntax.DataDeclaration { - Syntax.dataDeclarationKeyword = Syntax.DataOrNewtypeData, - Syntax.dataDeclarationContext = [], - Syntax.dataDeclarationHead = hd, - Syntax.dataDeclarationConstructors = cons, - Syntax.dataDeclarationDeriving = [ - deriv]}))) - Core.TypeWrap v0 -> Eithers.bind (newtypeCons elementName v0) (\cons -> Right (Syntax.DeclarationData (Syntax.DataDeclaration { - Syntax.dataDeclarationKeyword = Syntax.DataOrNewtypeNewtype, - Syntax.dataDeclarationContext = [], - Syntax.dataDeclarationHead = hd, - Syntax.dataDeclarationConstructors = [ - cons], - Syntax.dataDeclarationDeriving = [ - deriv]}))) - _ -> Eithers.bind (adaptTypeToHaskellAndEncode namespaces typ cx g) (\htype -> Right (Syntax.DeclarationType (Syntax.TypeDeclaration { - Syntax.typeDeclarationName = hd, - Syntax.typeDeclarationType = htype})))) (\decl -> Eithers.bind (Annotations.getTypeDescription cx g typ) (\comments -> Eithers.bind (Logic.ifElse includeTypeDefinitions (Eithers.bind (typeDecl namespaces elementName typ cx g) (\decl_ -> Right [ - decl_])) (Right [])) (\tdecls -> - let mainDecl = - Syntax.DeclarationWithComments { - Syntax.declarationWithCommentsBody = decl, - Syntax.declarationWithCommentsComments = comments} - nameDecls_ = nameDecls namespaces elementName typ - in (Right (Lists.concat [ - [ - mainDecl], - nameDecls_, - tdecls])))))))) - --- | Generate a Haskell declaration for a type definition constant -typeDecl :: Module.Namespaces Syntax.ModuleName -> Core.Name -> Core.Type -> Context.Context -> Graph.Graph -> Either (Context.InContext Errors.Error) Syntax.DeclarationWithComments -typeDecl namespaces name typ cx g = - - let typeName = \ns -> \name_ -> Names.qname ns (typeNameLocal name_) - typeNameLocal = - \name_ -> Strings.cat [ - "_", - (Names.localNameOf name_), - "_type_"] - rawTerm = Core_.type_ typ - rewrite = - \recurse -> \term -> - let variantResult = - case (Rewriting.deannotateTerm term) of - Core.TermUnion v0 -> Logic.ifElse (Equality.equal (Core.injectionTypeName v0) (Core.Name "hydra.core.Type")) (Just (Core.injectionField v0)) Nothing - _ -> Nothing - decodeString = - \term -> case (Rewriting.deannotateTerm term) of - Core.TermLiteral v0 -> case v0 of - Core.LiteralString v1 -> Just v1 - _ -> Nothing - _ -> Nothing - decodeName = - \term -> case (Rewriting.deannotateTerm term) of - Core.TermWrap v0 -> Logic.ifElse (Equality.equal (Core.wrappedTermTypeName v0) (Core.Name "hydra.core.Name")) (Maybes.map (\x -> Core.Name x) (decodeString (Core.wrappedTermBody v0))) Nothing - _ -> Nothing - forType = - \field -> - let fname = Core.fieldName field - fterm = Core.fieldTerm field - in (Logic.ifElse (Equality.equal fname (Core.Name "record")) Nothing (Logic.ifElse (Equality.equal fname (Core.Name "variable")) (Maybes.bind (decodeName fterm) forVariableType) Nothing)) - forVariableType = - \vname -> - let qname = Names.qualifyName vname - mns = Module.qualifiedNameNamespace qname - local = Module.qualifiedNameLocal qname - in (Maybes.map (\ns -> Core.TermVariable (Names.qname ns (Strings.cat [ - "_", - local, - "_type_"]))) mns) - in (Maybes.fromMaybe (recurse term) (Maybes.bind variantResult forType)) - finalTerm = Rewriting.rewriteTerm rewrite rawTerm - in (Eithers.bind (encodeTerm 0 namespaces finalTerm cx g) (\expr -> - let rhs = Syntax.RightHandSide expr - hname = Utils.simpleName (typeNameLocal name) - pat = Utils.applicationPattern hname [] - decl = - Syntax.DeclarationValueBinding (Syntax.ValueBindingSimple (Syntax.SimpleValueBinding { - Syntax.simpleValueBindingPattern = pat, - Syntax.simpleValueBindingRhs = rhs, - Syntax.simpleValueBindingLocalBindings = Nothing})) - in (Right (Syntax.DeclarationWithComments { - Syntax.declarationWithCommentsBody = decl, - Syntax.declarationWithCommentsComments = Nothing})))) - --- | Convert type scheme constraints to a map of type variables to typeclasses -typeSchemeConstraintsToClassMap :: Ord t0 => (Maybe (M.Map t0 Core.TypeVariableMetadata) -> M.Map t0 (S.Set Classes.TypeClass)) -typeSchemeConstraintsToClassMap maybeConstraints = - - let nameToTypeClass = - \className -> - let classNameStr = Core.unName className - isEq = Equality.equal classNameStr (Core.unName (Core.Name "equality")) - isOrd = Equality.equal classNameStr (Core.unName (Core.Name "ordering")) - in (Logic.ifElse isEq (Just Classes.TypeClassEquality) (Logic.ifElse isOrd (Just Classes.TypeClassOrdering) Nothing)) - in (Maybes.maybe Maps.empty (\constraints -> Maps.map (\meta -> Sets.fromList (Maybes.cat (Lists.map nameToTypeClass (Sets.toList (Core.typeVariableMetadataClasses meta))))) constraints) maybeConstraints) - --- | Whether to use the Hydra core import in generated modules -useCoreImport :: Bool -useCoreImport = True diff --git a/src/gen-main/haskell/Hydra/Ext/Haskell/Language.hs b/src/gen-main/haskell/Hydra/Ext/Haskell/Language.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Ext/Haskell/Language.hs +++ /dev/null @@ -1,149 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Language constraints and reserved words for Haskell - -module Hydra.Ext.Haskell.Language where - -import qualified Hydra.Coders as Coders -import qualified Hydra.Core as Core -import qualified Hydra.Lib.Lists as Lists -import qualified Hydra.Lib.Sets as Sets -import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | Language constraints for Haskell -haskellLanguage :: Coders.Language -haskellLanguage = - Coders.Language { - Coders.languageName = (Coders.LanguageName "hydra.ext.haskell"), - Coders.languageConstraints = Coders.LanguageConstraints { - Coders.languageConstraintsEliminationVariants = eliminationVariants, - Coders.languageConstraintsLiteralVariants = literalVariants, - Coders.languageConstraintsFloatTypes = floatTypes, - Coders.languageConstraintsFunctionVariants = functionVariants, - Coders.languageConstraintsIntegerTypes = integerTypes, - Coders.languageConstraintsTermVariants = termVariants, - Coders.languageConstraintsTypeVariants = typeVariants, - Coders.languageConstraintsTypes = typePredicate}} - where - eliminationVariants = - Sets.fromList [ - Variants.EliminationVariantRecord, - Variants.EliminationVariantUnion, - Variants.EliminationVariantWrap] - literalVariants = - Sets.fromList [ - Variants.LiteralVariantBinary, - Variants.LiteralVariantBoolean, - Variants.LiteralVariantFloat, - Variants.LiteralVariantInteger, - Variants.LiteralVariantString] - floatTypes = - Sets.fromList [ - Core.FloatTypeFloat32, - Core.FloatTypeFloat64] - functionVariants = - Sets.fromList [ - Variants.FunctionVariantElimination, - Variants.FunctionVariantLambda, - Variants.FunctionVariantPrimitive] - integerTypes = - Sets.fromList [ - Core.IntegerTypeBigint, - Core.IntegerTypeInt8, - Core.IntegerTypeInt16, - Core.IntegerTypeInt32, - Core.IntegerTypeInt64] - termVariants = - Sets.fromList [ - Variants.TermVariantAnnotated, - Variants.TermVariantApplication, - Variants.TermVariantEither, - Variants.TermVariantFunction, - Variants.TermVariantLet, - Variants.TermVariantList, - Variants.TermVariantLiteral, - Variants.TermVariantMap, - Variants.TermVariantMaybe, - Variants.TermVariantPair, - Variants.TermVariantRecord, - Variants.TermVariantSet, - Variants.TermVariantUnion, - Variants.TermVariantUnit, - Variants.TermVariantVariable, - Variants.TermVariantWrap] - typeVariants = - Sets.fromList [ - Variants.TypeVariantAnnotated, - Variants.TypeVariantApplication, - Variants.TypeVariantEither, - Variants.TypeVariantFunction, - Variants.TypeVariantForall, - Variants.TypeVariantList, - Variants.TypeVariantLiteral, - Variants.TypeVariantMap, - Variants.TypeVariantMaybe, - Variants.TypeVariantPair, - Variants.TypeVariantRecord, - Variants.TypeVariantSet, - Variants.TypeVariantUnion, - Variants.TypeVariantUnit, - Variants.TypeVariantVariable, - Variants.TypeVariantVoid, - Variants.TypeVariantWrap] - typePredicate = \_ -> True - --- | Created on 2025-02-28 using GHCi 9.6.6 --- | --- | You can reproduce these lists of symbols by issuing the command `:browse Prelude` in GHCi, pasting the results into --- | /tmp/browse_Prelude.txt, and then running the Bash command provided with each list. --- | --- | See also https://www.haskell.org/onlinereport/standard-prelude.html -reservedWords :: S.Set String -reservedWords = Sets.fromList (Lists.concat2 keywordSymbols reservedSymbols) - where - keywordSymbols = - [ - "case", - "class", - "data", - "default", - "deriving", - "do", - "else", - "forall", - "foreign", - "if", - "import", - "in", - "infix", - "infixl", - "infixr", - "instance", - "let", - "module", - "newtype", - "of", - "then", - "type", - "where"] - reservedSymbols = - [ - "Bool", - "Double", - "False", - "Float", - "Int", - "Integer", - "Just", - "Maybe", - "Nothing", - "Ord", - "Show", - "String", - "True"] diff --git a/src/gen-main/haskell/Hydra/Ext/Haskell/Operators.hs b/src/gen-main/haskell/Hydra/Ext/Haskell/Operators.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Ext/Haskell/Operators.hs +++ /dev/null @@ -1,158 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | AST operators for Haskell - -module Hydra.Ext.Haskell.Operators where - -import qualified Hydra.Ast as Ast -import qualified Hydra.Lib.Math as Math -import qualified Hydra.Serialization as Serialization -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | Logical AND operator (&&) -andOp :: Ast.Op -andOp = Serialization.op "&&" 3 Ast.AssociativityRight - --- | Applicative apply operator (<*>) -apOp :: Ast.Op -apOp = Serialization.op "<*>" 4 Ast.AssociativityLeft - --- | Function application operator (whitespace) -appOp :: Ast.Op -appOp = - Ast.Op { - Ast.opSymbol = (Ast.Symbol ""), - Ast.opPadding = Ast.Padding { - Ast.paddingLeft = Ast.WsNone, - Ast.paddingRight = Ast.WsSpace}, - Ast.opPrecedence = (Ast.Precedence 0), - Ast.opAssociativity = Ast.AssociativityLeft} - --- | Low-precedence function application ($) -applyOp :: Ast.Op -applyOp = Serialization.op "$" 0 Ast.AssociativityRight - --- | Function type arrow (->) -arrowOp :: Ast.Op -arrowOp = Serialization.op "->" (Math.negate 1) Ast.AssociativityRight - --- | Type class constraint arrow (=>) -assertOp :: Ast.Op -assertOp = Serialization.op "=>" 0 Ast.AssociativityNone - --- | Monadic bind operator (>>=) -bindOp :: Ast.Op -bindOp = Serialization.op ">>=" 1 Ast.AssociativityLeft - --- | Case alternative arrow (->) -caseOp :: Ast.Op -caseOp = Serialization.op "->" 0 Ast.AssociativityNone - --- | Function composition (.) -composeOp :: Ast.Op -composeOp = Serialization.op "." 9 Ast.AssociativityLeft - --- | List concatenation (++) -concatOp :: Ast.Op -concatOp = Serialization.op "++" 5 Ast.AssociativityRight - --- | List cons (:) -consOp :: Ast.Op -consOp = Serialization.op ":" 5 Ast.AssociativityRight - --- | Definition operator (=) -defineOp :: Ast.Op -defineOp = Serialization.op "=" 0 Ast.AssociativityNone - --- | Semigroup append (<>) -diamondOp :: Ast.Op -diamondOp = Serialization.op "<>" 6 Ast.AssociativityRight - --- | Integer division (`div`) -divOp :: Ast.Op -divOp = Serialization.op "`div`" 7 Ast.AssociativityLeft - --- | Fractional division (/) -divideOp :: Ast.Op -divideOp = Serialization.op "/" 7 Ast.AssociativityLeft - --- | List membership (`elem`) -elemOp :: Ast.Op -elemOp = Serialization.op "`elem`" 4 Ast.AssociativityNone - --- | Equality comparison (==) -equalOp :: Ast.Op -equalOp = Serialization.op "==" 4 Ast.AssociativityNone - --- | Functor map (<$>) -fmapOp :: Ast.Op -fmapOp = Serialization.op "<$>" 4 Ast.AssociativityLeft - --- | Greater than (>) -gtOp :: Ast.Op -gtOp = Serialization.op ">" 4 Ast.AssociativityNone - --- | Greater than or equal (>=) -gteOp :: Ast.Op -gteOp = Serialization.op ">=" 4 Ast.AssociativityNone - --- | List indexing (!!) -indexOp :: Ast.Op -indexOp = Serialization.op "!!" 9 Ast.AssociativityLeft - --- | Lambda body arrow (->) -lambdaOp :: Ast.Op -lambdaOp = Serialization.op "->" (Math.negate 1) Ast.AssociativityRight - --- | Less than (<) -ltOp :: Ast.Op -ltOp = Serialization.op "<" 4 Ast.AssociativityNone - --- | Less than or equal (<=) -lteOp :: Ast.Op -lteOp = Serialization.op ">=" 4 Ast.AssociativityNone - --- | Subtraction (-). Originally: associativityLeft -minusOp :: Ast.Op -minusOp = Serialization.op "-" 6 Ast.AssociativityBoth - --- | Modulo (`mod`) -modOp :: Ast.Op -modOp = Serialization.op "`mod`" 7 Ast.AssociativityLeft - --- | Multiplication (*). Originally: associativityLeft -multOp :: Ast.Op -multOp = Serialization.op "*" 7 Ast.AssociativityBoth - --- | Not equal (/=) -neqOp :: Ast.Op -neqOp = Serialization.op "/=" 4 Ast.AssociativityNone - --- | List non-membership (`notElem`) -notElemOp :: Ast.Op -notElemOp = Serialization.op "`notElem`" 4 Ast.AssociativityNone - --- | Logical OR (||) -orOp :: Ast.Op -orOp = Serialization.op "||" 2 Ast.AssociativityRight - --- | Addition (+). Originally: associativityLeft -plusOp :: Ast.Op -plusOp = Serialization.op "+" 6 Ast.AssociativityBoth - --- | Integer quotient (`quot`) -quotOp :: Ast.Op -quotOp = Serialization.op "`quot`" 7 Ast.AssociativityLeft - --- | Integer remainder (`rem`) -remOp :: Ast.Op -remOp = Serialization.op "`rem`" 7 Ast.AssociativityLeft - --- | Type annotation (::) -typeOp :: Ast.Op -typeOp = Serialization.op "::" 0 Ast.AssociativityNone diff --git a/src/gen-main/haskell/Hydra/Ext/Haskell/Serde.hs b/src/gen-main/haskell/Hydra/Ext/Haskell/Serde.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Ext/Haskell/Serde.hs +++ /dev/null @@ -1,471 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Haskell operator precendence and associativity are drawn from: --- | https://self-learning-java-tutorial.blogspot.com/2016/04/haskell-operator-precedence.html --- | Other operators were investigated using GHCi, e.g. ":info (->)" --- | Operator names are drawn (loosely) from: --- | https://stackoverflow.com/questions/7746894/are-there-pronounceable-names-for-common-haskell-operators - -module Hydra.Ext.Haskell.Serde where - -import qualified Hydra.Ast as Ast -import qualified Hydra.Constants as Constants -import qualified Hydra.Ext.Haskell.Operators as Operators -import qualified Hydra.Ext.Haskell.Syntax as Syntax -import qualified Hydra.Lib.Equality as Equality -import qualified Hydra.Lib.Lists as Lists -import qualified Hydra.Lib.Literals as Literals -import qualified Hydra.Lib.Logic as Logic -import qualified Hydra.Lib.Maybes as Maybes -import qualified Hydra.Lib.Strings as Strings -import qualified Hydra.Serialization as Serialization -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | Convert a pattern-matching alternative to an AST expression -alternativeToExpr :: Syntax.Alternative -> Ast.Expr -alternativeToExpr alt = - Serialization.structuralSpaceSep [ - patternToExpr (Syntax.alternativePattern alt), - (Serialization.cst "->"), - (caseRhsToExpr (Syntax.alternativeRhs alt))] - --- | Convert a function application expression to an AST expression -applicationExpressionToExpr :: Syntax.ApplicationExpression -> Ast.Expr -applicationExpressionToExpr app = - Serialization.ifx Operators.appOp (expressionToExpr (Syntax.applicationExpressionFunction app)) (expressionToExpr (Syntax.applicationExpressionArgument app)) - --- | Convert an application pattern to an AST expression -applicationPatternToExpr :: Syntax.ApplicationPattern -> Ast.Expr -applicationPatternToExpr appPat = - - let name = Syntax.applicationPatternName appPat - pats = Syntax.applicationPatternArgs appPat - in (Serialization.spaceSep (Lists.cons (nameToExpr name) (Lists.map patternToExpr pats))) - --- | Convert a type class assertion to an AST expression -assertionToExpr :: Syntax.Assertion -> Ast.Expr -assertionToExpr sert = - case sert of - Syntax.AssertionClass v0 -> classAssertionToExpr v0 - Syntax.AssertionTuple v0 -> Serialization.parenList False (Lists.map assertionToExpr v0) - --- | Convert a case expression to an AST expression -caseExpressionToExpr :: Syntax.CaseExpression -> Ast.Expr -caseExpressionToExpr caseExpr = - - let cs = Syntax.caseExpressionCase caseExpr - alts = Syntax.caseExpressionAlternatives caseExpr - ofOp = - Ast.Op { - Ast.opSymbol = (Ast.Symbol "of"), - Ast.opPadding = Ast.Padding { - Ast.paddingLeft = Ast.WsSpace, - Ast.paddingRight = (Ast.WsBreakAndIndent " ")}, - Ast.opPrecedence = (Ast.Precedence 0), - Ast.opAssociativity = Ast.AssociativityNone} - lhs = - Serialization.spaceSep [ - Serialization.cst "case", - (expressionToExpr cs)] - rhs = Serialization.newlineSep (Lists.map alternativeToExpr alts) - in (Serialization.ifx ofOp lhs rhs) - --- | Convert a case right-hand side to an AST expression -caseRhsToExpr :: Syntax.CaseRhs -> Ast.Expr -caseRhsToExpr rhs = expressionToExpr (Syntax.unCaseRhs rhs) - --- | Convert a class assertion to an AST expression -classAssertionToExpr :: Syntax.ClassAssertion -> Ast.Expr -classAssertionToExpr clsAsrt = - - let name = Syntax.classAssertionName clsAsrt - types = Syntax.classAssertionTypes clsAsrt - in (Serialization.spaceSep (Lists.cons (nameToExpr name) [ - Serialization.commaSep Serialization.halfBlockStyle (Lists.map typeToExpr types)])) - --- | Convert a record construction expression to an AST expression -constructRecordExpressionToExpr :: Syntax.ConstructRecordExpression -> Ast.Expr -constructRecordExpressionToExpr constructRecord = - - let name = Syntax.constructRecordExpressionName constructRecord - updates = Syntax.constructRecordExpressionFields constructRecord - fromUpdate = - \update -> - let fn = Syntax.fieldUpdateName update - val = Syntax.fieldUpdateValue update - in (Serialization.ifx Operators.defineOp (nameToExpr fn) (expressionToExpr val)) - body = Serialization.commaSep Serialization.halfBlockStyle (Lists.map fromUpdate updates) - in (Serialization.spaceSep (Lists.cons (nameToExpr name) [ - Serialization.brackets Serialization.curlyBraces Serialization.halfBlockStyle body])) - --- | Convert a data constructor to an AST expression -constructorToExpr :: Syntax.Constructor -> Ast.Expr -constructorToExpr cons = - case cons of - Syntax.ConstructorOrdinary v0 -> - let name = Syntax.ordinaryConstructorName v0 - types = Syntax.ordinaryConstructorFields v0 - in (Serialization.spaceSep (Lists.cons (nameToExpr name) [ - Serialization.spaceSep (Lists.map typeToExpr types)])) - Syntax.ConstructorRecord v0 -> - let name = Syntax.recordConstructorName v0 - fields = Syntax.recordConstructorFields v0 - in (Serialization.spaceSep (Lists.cons (nameToExpr name) [ - Serialization.curlyBracesList Nothing Serialization.halfBlockStyle (Lists.map fieldWithCommentsToExpr fields)])) - --- | Convert a data constructor with comments to an AST expression -constructorWithCommentsToExpr :: Syntax.ConstructorWithComments -> Ast.Expr -constructorWithCommentsToExpr consWithComments = - - let body = Syntax.constructorWithCommentsBody consWithComments - mc = Syntax.constructorWithCommentsComments consWithComments - in (Maybes.maybe (constructorToExpr body) (\c -> Serialization.newlineSep (Lists.cons (Serialization.cst (toHaskellComments c)) [ - constructorToExpr body])) mc) - --- | Convert a data/newtype keyword to an AST expression -dataOrNewtypeToExpr :: Syntax.DataOrNewtype -> Ast.Expr -dataOrNewtypeToExpr kw = - case kw of - Syntax.DataOrNewtypeData -> Serialization.cst "data" - Syntax.DataOrNewtypeNewtype -> Serialization.cst "newtype" - --- | Convert a declaration head to an AST expression -declarationHeadToExpr :: Syntax.DeclarationHead -> Ast.Expr -declarationHeadToExpr hd = - case hd of - Syntax.DeclarationHeadApplication v0 -> - let fun = Syntax.applicationDeclarationHeadFunction v0 - op = Syntax.applicationDeclarationHeadOperand v0 - in (Serialization.spaceSep (Lists.cons (declarationHeadToExpr fun) [ - variableToExpr op])) - Syntax.DeclarationHeadSimple v0 -> nameToExpr v0 - --- | Convert a declaration to an AST expression -declarationToExpr :: Syntax.Declaration -> Ast.Expr -declarationToExpr decl = - case decl of - Syntax.DeclarationData v0 -> - let kw = Syntax.dataDeclarationKeyword v0 - hd = Syntax.dataDeclarationHead v0 - cons = Syntax.dataDeclarationConstructors v0 - deriv = Syntax.dataDeclarationDeriving v0 - derivCat = Lists.concat (Lists.map Syntax.unDeriving deriv) - constructors = Serialization.orSep Serialization.halfBlockStyle (Lists.map constructorWithCommentsToExpr cons) - derivingClause = - Logic.ifElse (Lists.null derivCat) [] [ - Serialization.spaceSep (Lists.cons (Serialization.cst "deriving") [ - Serialization.parenList False (Lists.map nameToExpr derivCat)])] - mainParts = - [ - Serialization.spaceSep (Lists.cons (dataOrNewtypeToExpr kw) (Lists.cons (declarationHeadToExpr hd) [ - Serialization.cst "="])), - constructors] - in (Serialization.indentBlock (Lists.concat2 mainParts derivingClause)) - Syntax.DeclarationType v0 -> - let hd = Syntax.typeDeclarationName v0 - typ = Syntax.typeDeclarationType v0 - in (Serialization.spaceSep (Lists.cons (Serialization.cst "type") (Lists.cons (declarationHeadToExpr hd) (Lists.cons (Serialization.cst "=") [ - typeToExpr typ])))) - Syntax.DeclarationValueBinding v0 -> valueBindingToExpr v0 - Syntax.DeclarationTypedBinding v0 -> - let typeSig = Syntax.typedBindingTypeSignature v0 - vb = Syntax.typedBindingValueBinding v0 - name = Syntax.typeSignatureName typeSig - htype = Syntax.typeSignatureType typeSig - in (Serialization.newlineSep (Lists.cons (Serialization.structuralSpaceSep [ - nameToExpr name, - (Serialization.cst "::"), - (typeToExpr htype)]) [ - valueBindingToExpr vb])) - --- | Convert a declaration with comments to an AST expression -declarationWithCommentsToExpr :: Syntax.DeclarationWithComments -> Ast.Expr -declarationWithCommentsToExpr declWithComments = - - let body = Syntax.declarationWithCommentsBody declWithComments - mc = Syntax.declarationWithCommentsComments declWithComments - in (Maybes.maybe (declarationToExpr body) (\c -> Serialization.newlineSep (Lists.cons (Serialization.cst (toHaskellComments c)) [ - declarationToExpr body])) mc) - --- | Convert a Haskell expression to an AST expression -expressionToExpr :: Syntax.Expression -> Ast.Expr -expressionToExpr expr = - case expr of - Syntax.ExpressionApplication v0 -> applicationExpressionToExpr v0 - Syntax.ExpressionCase v0 -> caseExpressionToExpr v0 - Syntax.ExpressionConstructRecord v0 -> constructRecordExpressionToExpr v0 - Syntax.ExpressionDo v0 -> Serialization.indentBlock (Lists.cons (Serialization.cst "do") (Lists.map statementToExpr v0)) - Syntax.ExpressionIf v0 -> ifExpressionToExpr v0 - Syntax.ExpressionLiteral v0 -> literalToExpr v0 - Syntax.ExpressionLambda v0 -> Serialization.parenthesize (lambdaExpressionToExpr v0) - Syntax.ExpressionLet v0 -> - let bindings = Syntax.letExpressionBindings v0 - inner = Syntax.letExpressionInner v0 - encodeBinding = \binding -> Serialization.indentSubsequentLines " " (localBindingToExpr binding) - in (Serialization.indentBlock (Lists.cons (Serialization.cst "") (Lists.cons (Serialization.spaceSep (Lists.cons (Serialization.cst "let") [ - Serialization.customIndentBlock " " (Lists.map encodeBinding bindings)])) [ - Serialization.spaceSep (Lists.cons (Serialization.cst "in") [ - expressionToExpr inner])]))) - Syntax.ExpressionList v0 -> Serialization.bracketList Serialization.halfBlockStyle (Lists.map expressionToExpr v0) - Syntax.ExpressionParens v0 -> Serialization.parenthesize (expressionToExpr v0) - Syntax.ExpressionTuple v0 -> Serialization.parenList False (Lists.map expressionToExpr v0) - Syntax.ExpressionVariable v0 -> nameToExpr v0 - --- | Convert a field declaration to an AST expression -fieldToExpr :: Syntax.Field -> Ast.Expr -fieldToExpr field = - - let name = Syntax.fieldName field - typ = Syntax.fieldType field - in (Serialization.spaceSep (Lists.cons (nameToExpr name) (Lists.cons (Serialization.cst "::") [ - typeToExpr typ]))) - --- | Convert a field with comments to an AST expression -fieldWithCommentsToExpr :: Syntax.FieldWithComments -> Ast.Expr -fieldWithCommentsToExpr fieldWithComments = - - let field = Syntax.fieldWithCommentsField fieldWithComments - mc = Syntax.fieldWithCommentsComments fieldWithComments - in (Maybes.maybe (fieldToExpr field) (\c -> Serialization.newlineSep (Lists.cons (Serialization.cst (toHaskellComments c)) [ - fieldToExpr field])) mc) - --- | Convert an if-then-else expression to an AST expression -ifExpressionToExpr :: Syntax.IfExpression -> Ast.Expr -ifExpressionToExpr ifExpr = - - let eif = Syntax.ifExpressionCondition ifExpr - ethen = Syntax.ifExpressionThen ifExpr - eelse = Syntax.ifExpressionElse ifExpr - ifOp = - Ast.Op { - Ast.opSymbol = (Ast.Symbol ""), - Ast.opPadding = Ast.Padding { - Ast.paddingLeft = Ast.WsNone, - Ast.paddingRight = (Ast.WsBreakAndIndent " ")}, - Ast.opPrecedence = (Ast.Precedence 0), - Ast.opAssociativity = Ast.AssociativityNone} - body = - Serialization.newlineSep (Lists.cons (Serialization.spaceSep (Lists.cons (Serialization.cst "then") [ - expressionToExpr ethen])) [ - Serialization.spaceSep (Lists.cons (Serialization.cst "else") [ - expressionToExpr eelse])]) - in (Serialization.ifx ifOp (Serialization.spaceSep (Lists.cons (Serialization.cst "if") [ - expressionToExpr eif])) body) - --- | Convert an import/export specification to an AST expression -importExportSpecToExpr :: Syntax.ImportExportSpec -> Ast.Expr -importExportSpecToExpr spec = nameToExpr (Syntax.importExportSpecName spec) - --- | Convert an import statement to an AST expression -importToExpr :: Syntax.Import -> Ast.Expr -importToExpr import_ = - - let qual = Syntax.importQualified import_ - modName = Syntax.importModule import_ - mod = Syntax.importAs import_ - mspec = Syntax.importSpec import_ - name = Syntax.unModuleName modName - hidingSec = - \spec -> case spec of - Syntax.SpecImportHiding v0 -> Serialization.spaceSep (Lists.cons (Serialization.cst "hiding ") [ - Serialization.parens (Serialization.commaSep Serialization.inlineStyle (Lists.map importExportSpecToExpr v0))]) - parts = - Maybes.cat [ - Just (Serialization.cst "import"), - (Logic.ifElse qual (Just (Serialization.cst "qualified")) Nothing), - (Just (Serialization.cst name)), - (Maybes.map (\m -> Serialization.cst (Strings.cat2 "as " (Syntax.unModuleName m))) mod), - (Maybes.map hidingSec mspec)] - in (Serialization.spaceSep parts) - --- | Convert a lambda expression to an AST expression -lambdaExpressionToExpr :: Syntax.LambdaExpression -> Ast.Expr -lambdaExpressionToExpr lambdaExpr = - - let bindings = Syntax.lambdaExpressionBindings lambdaExpr - inner = Syntax.lambdaExpressionInner lambdaExpr - head = Serialization.spaceSep (Lists.map patternToExpr bindings) - body = expressionToExpr inner - in (Serialization.ifx Operators.lambdaOp (Serialization.prefix "\\" head) body) - --- | Convert a literal value to an AST expression -literalToExpr :: Syntax.Literal -> Ast.Expr -literalToExpr lit = - - let parensIfNeg = - \b -> \e -> Logic.ifElse b (Strings.cat [ - "(", - e, - ")"]) e - in (Serialization.cst (case lit of - Syntax.LiteralChar v0 -> Literals.showString (Literals.showUint16 v0) - Syntax.LiteralDouble v0 -> parensIfNeg (Equality.lt v0 0.0) (Literals.showFloat64 v0) - Syntax.LiteralFloat v0 -> parensIfNeg (Equality.lt v0 0.0) (Literals.showFloat32 v0) - Syntax.LiteralInt v0 -> parensIfNeg (Equality.lt v0 0) (Literals.showInt32 v0) - Syntax.LiteralInteger v0 -> parensIfNeg (Equality.lt v0 0) (Literals.showBigint v0) - Syntax.LiteralString v0 -> Literals.showString v0)) - --- | Convert a local binding to an AST expression -localBindingToExpr :: Syntax.LocalBinding -> Ast.Expr -localBindingToExpr binding = - case binding of - Syntax.LocalBindingSignature v0 -> typeSignatureToExpr v0 - Syntax.LocalBindingValue v0 -> valueBindingToExpr v0 - --- | Convert a module head to an AST expression -moduleHeadToExpr :: Syntax.ModuleHead -> Ast.Expr -moduleHeadToExpr moduleHead = - - let mc = Syntax.moduleHeadComments moduleHead - modName = Syntax.moduleHeadName moduleHead - mname = Syntax.unModuleName modName - head = - Serialization.spaceSep (Lists.cons (Serialization.cst "module") (Lists.cons (Serialization.cst mname) [ - Serialization.cst "where"])) - in (Maybes.maybe head (\c -> Serialization.newlineSep (Lists.cons (Serialization.cst (toHaskellComments c)) (Lists.cons (Serialization.cst "") [ - head]))) mc) - --- | Convert a Haskell module to an AST expression -moduleToExpr :: Syntax.Module -> Ast.Expr -moduleToExpr module_ = - - let mh = Syntax.moduleHead module_ - imports = Syntax.moduleImports module_ - decls = Syntax.moduleDeclarations module_ - warning = [ - Serialization.cst (toSimpleComments Constants.warningAutoGeneratedFile)] - headerLine = Maybes.maybe [] (\h -> [ - moduleHeadToExpr h]) mh - declLines = Lists.map declarationWithCommentsToExpr decls - importLines = Logic.ifElse (Lists.null imports) [] [ - Serialization.newlineSep (Lists.map importToExpr imports)] - in (Serialization.doubleNewlineSep (Lists.concat [ - warning, - headerLine, - importLines, - declLines])) - --- | Convert a Haskell name to an AST expression -nameToExpr :: Syntax.Name -> Ast.Expr -nameToExpr name = - Serialization.cst (case name of - Syntax.NameImplicit v0 -> Strings.cat2 "?" (writeQualifiedName v0) - Syntax.NameNormal v0 -> writeQualifiedName v0 - Syntax.NameParens v0 -> Strings.cat [ - "(", - (writeQualifiedName v0), - ")"]) - --- | Convert a pattern to an AST expression -patternToExpr :: Syntax.Pattern -> Ast.Expr -patternToExpr pat = - case pat of - Syntax.PatternApplication v0 -> applicationPatternToExpr v0 - Syntax.PatternList v0 -> Serialization.bracketList Serialization.halfBlockStyle (Lists.map patternToExpr v0) - Syntax.PatternLiteral v0 -> literalToExpr v0 - Syntax.PatternName v0 -> nameToExpr v0 - Syntax.PatternParens v0 -> Serialization.parenthesize (patternToExpr v0) - Syntax.PatternTuple v0 -> Serialization.parenList False (Lists.map patternToExpr v0) - Syntax.PatternWildcard -> Serialization.cst "_" - --- | Convert a right-hand side to an AST expression -rightHandSideToExpr :: Syntax.RightHandSide -> Ast.Expr -rightHandSideToExpr rhs = expressionToExpr (Syntax.unRightHandSide rhs) - --- | Convert a statement to an AST expression -statementToExpr :: Syntax.Statement -> Ast.Expr -statementToExpr stmt = expressionToExpr (Syntax.unStatement stmt) - --- | Convert a string to Haddock documentation comments -toHaskellComments :: String -> String -toHaskellComments c = Strings.intercalate "\n" (Lists.map (\s -> Strings.cat2 "-- | " s) (Strings.lines c)) - --- | Convert a string to simple line comments -toSimpleComments :: String -> String -toSimpleComments c = Strings.intercalate "\n" (Lists.map (\s -> Strings.cat2 "-- " s) (Strings.lines c)) - --- | Convert a type signature to an AST expression -typeSignatureToExpr :: Syntax.TypeSignature -> Ast.Expr -typeSignatureToExpr typeSig = - - let name = Syntax.typeSignatureName typeSig - typ = Syntax.typeSignatureType typeSig - nameExpr = nameToExpr name - typeExpr = typeToExpr typ - inlineSig = - Serialization.structuralSpaceSep [ - nameExpr, - (Serialization.cst "::"), - typeExpr] - in (Logic.ifElse (Equality.gt (Serialization.expressionLength inlineSig) 120) (Serialization.newlineSep [ - Serialization.spaceSep [ - nameExpr, - (Serialization.cst "::")], - (Serialization.tabIndent typeExpr)]) inlineSig) - --- | Convert a Haskell type to an AST expression -typeToExpr :: Syntax.Type -> Ast.Expr -typeToExpr htype = - case htype of - Syntax.TypeApplication v0 -> - let lhs = Syntax.applicationTypeContext v0 - rhs = Syntax.applicationTypeArgument v0 - in (Serialization.ifx Operators.appOp (typeToExpr lhs) (typeToExpr rhs)) - Syntax.TypeCtx v0 -> - let ctx = Syntax.contextTypeCtx v0 - typ = Syntax.contextTypeType v0 - in (Serialization.ifx Operators.assertOp (assertionToExpr ctx) (typeToExpr typ)) - Syntax.TypeFunction v0 -> - let dom = Syntax.functionTypeDomain v0 - cod = Syntax.functionTypeCodomain v0 - in (Serialization.ifx Operators.arrowOp (typeToExpr dom) (typeToExpr cod)) - Syntax.TypeList v0 -> Serialization.bracketList Serialization.inlineStyle [ - typeToExpr v0] - Syntax.TypeTuple v0 -> Serialization.parenList False (Lists.map typeToExpr v0) - Syntax.TypeVariable v0 -> nameToExpr v0 - --- | Convert a value binding to an AST expression -valueBindingToExpr :: Syntax.ValueBinding -> Ast.Expr -valueBindingToExpr vb = - case vb of - Syntax.ValueBindingSimple v0 -> - let pat = Syntax.simpleValueBindingPattern v0 - rhs = Syntax.simpleValueBindingRhs v0 - local = Syntax.simpleValueBindingLocalBindings v0 - lhsExpr = patternToExpr pat - rhsExpr = rightHandSideToExpr rhs - inlineBody = - Serialization.structuralSpaceSep [ - lhsExpr, - (Serialization.cst "="), - rhsExpr] - body = - Logic.ifElse (Equality.gt (Serialization.expressionLength inlineBody) 120) (Serialization.newlineSep [ - Serialization.spaceSep [ - lhsExpr, - (Serialization.cst "=")], - (Serialization.tabIndent rhsExpr)]) inlineBody - in (Maybes.maybe body (\localBindings -> - let bindings = Syntax.unLocalBindings localBindings - in (Serialization.indentBlock (Lists.cons body [ - Serialization.indentBlock (Lists.cons (Serialization.cst "where") (Lists.map localBindingToExpr bindings))]))) local) - --- | Convert a type variable to an AST expression -variableToExpr :: Syntax.Variable -> Ast.Expr -variableToExpr variable = nameToExpr (Syntax.unVariable variable) - --- | Write a qualified name as a string -writeQualifiedName :: Syntax.QualifiedName -> String -writeQualifiedName qname = - - let qualifiers = Syntax.qualifiedNameQualifiers qname - unqual = Syntax.qualifiedNameUnqualified qname - h = \namePart -> Syntax.unNamePart namePart - allParts = Lists.concat2 (Lists.map h qualifiers) [ - h unqual] - in (Strings.intercalate "." allParts) diff --git a/src/gen-main/haskell/Hydra/Ext/Haskell/Syntax.hs b/src/gen-main/haskell/Hydra/Ext/Haskell/Syntax.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Ext/Haskell/Syntax.hs +++ /dev/null @@ -1,1111 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | A Haskell syntax model, loosely based on Language.Haskell.Tools.AST - -module Hydra.Ext.Haskell.Syntax where - -import qualified Hydra.Core as Core -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | A pattern-matching alternative -data Alternative = - Alternative { - -- | The pattern to match - alternativePattern :: Pattern, - -- | The right-hand side of the alternative - alternativeRhs :: CaseRhs, - -- | Optional local bindings - alternativeBinds :: (Maybe LocalBindings)} - deriving (Eq, Ord, Read, Show) - -_Alternative = Core.Name "hydra.ext.haskell.syntax.Alternative" - -_Alternative_pattern = Core.Name "pattern" - -_Alternative_rhs = Core.Name "rhs" - -_Alternative_binds = Core.Name "binds" - --- | A type assertion -data Assertion = - -- | A class assertion - AssertionClass ClassAssertion | - -- | A tuple of assertions - AssertionTuple [Assertion] - deriving (Eq, Ord, Read, Show) - -_Assertion = Core.Name "hydra.ext.haskell.syntax.Assertion" - -_Assertion_class = Core.Name "class" - -_Assertion_tuple = Core.Name "tuple" - --- | A class assertion -data ClassAssertion = - ClassAssertion { - -- | The name of the class - classAssertionName :: Name, - -- | The types to which the class is applied - classAssertionTypes :: [Type]} - deriving (Eq, Ord, Read, Show) - -_ClassAssertion = Core.Name "hydra.ext.haskell.syntax.ClassAssertion" - -_ClassAssertion_name = Core.Name "name" - -_ClassAssertion_types = Core.Name "types" - --- | The right-hand side of a pattern-matching alternative -newtype CaseRhs = - CaseRhs { - unCaseRhs :: Expression} - deriving (Eq, Ord, Read, Show) - -_CaseRhs = Core.Name "hydra.ext.haskell.syntax.CaseRhs" - --- | A data constructor -data Constructor = - -- | An ordinary (positional) constructor - ConstructorOrdinary OrdinaryConstructor | - -- | A record constructor - ConstructorRecord RecordConstructor - deriving (Eq, Ord, Read, Show) - -_Constructor = Core.Name "hydra.ext.haskell.syntax.Constructor" - -_Constructor_ordinary = Core.Name "ordinary" - -_Constructor_record = Core.Name "record" - --- | An ordinary (positional) data constructor -data OrdinaryConstructor = - OrdinaryConstructor { - -- | The name of the constructor - ordinaryConstructorName :: Name, - -- | The types of the positional fields - ordinaryConstructorFields :: [Type]} - deriving (Eq, Ord, Read, Show) - -_OrdinaryConstructor = Core.Name "hydra.ext.haskell.syntax.OrdinaryConstructor" - -_OrdinaryConstructor_name = Core.Name "name" - -_OrdinaryConstructor_fields = Core.Name "fields" - --- | A record-style data constructor -data RecordConstructor = - RecordConstructor { - -- | The name of the constructor - recordConstructorName :: Name, - -- | The named fields of the record - recordConstructorFields :: [FieldWithComments]} - deriving (Eq, Ord, Read, Show) - -_RecordConstructor = Core.Name "hydra.ext.haskell.syntax.RecordConstructor" - -_RecordConstructor_name = Core.Name "name" - -_RecordConstructor_fields = Core.Name "fields" - --- | A data constructor together with any comments -data ConstructorWithComments = - ConstructorWithComments { - -- | The constructor - constructorWithCommentsBody :: Constructor, - -- | Optional comments - constructorWithCommentsComments :: (Maybe String)} - deriving (Eq, Ord, Read, Show) - -_ConstructorWithComments = Core.Name "hydra.ext.haskell.syntax.ConstructorWithComments" - -_ConstructorWithComments_body = Core.Name "body" - -_ConstructorWithComments_comments = Core.Name "comments" - --- | A data type declaration -data DataDeclaration = - DataDeclaration { - -- | The 'data' or 'newtype' keyword - dataDeclarationKeyword :: DataOrNewtype, - -- | Type class constraints - dataDeclarationContext :: [Assertion], - -- | The declaration head - dataDeclarationHead :: DeclarationHead, - -- | The data constructors - dataDeclarationConstructors :: [ConstructorWithComments], - -- | Derived type class instances - dataDeclarationDeriving :: [Deriving]} - deriving (Eq, Ord, Read, Show) - -_DataDeclaration = Core.Name "hydra.ext.haskell.syntax.DataDeclaration" - -_DataDeclaration_keyword = Core.Name "keyword" - -_DataDeclaration_context = Core.Name "context" - -_DataDeclaration_head = Core.Name "head" - -_DataDeclaration_constructors = Core.Name "constructors" - -_DataDeclaration_deriving = Core.Name "deriving" - --- | The 'data' versus 'newtype keyword -data DataOrNewtype = - DataOrNewtypeData | - DataOrNewtypeNewtype - deriving (Eq, Ord, Read, Show) - -_DataOrNewtype = Core.Name "hydra.ext.haskell.syntax.DataOrNewtype" - -_DataOrNewtype_data = Core.Name "data" - -_DataOrNewtype_newtype = Core.Name "newtype" - --- | A data declaration together with any comments -data DeclarationWithComments = - DeclarationWithComments { - -- | The declaration - declarationWithCommentsBody :: Declaration, - -- | Optional comments - declarationWithCommentsComments :: (Maybe String)} - deriving (Eq, Ord, Read, Show) - -_DeclarationWithComments = Core.Name "hydra.ext.haskell.syntax.DeclarationWithComments" - -_DeclarationWithComments_body = Core.Name "body" - -_DeclarationWithComments_comments = Core.Name "comments" - --- | A data or value declaration -data Declaration = - -- | A data type declaration - DeclarationData DataDeclaration | - -- | A type synonym declaration - DeclarationType TypeDeclaration | - -- | A value binding - DeclarationValueBinding ValueBinding | - -- | A typed binding - DeclarationTypedBinding TypedBinding - deriving (Eq, Ord, Read, Show) - -_Declaration = Core.Name "hydra.ext.haskell.syntax.Declaration" - -_Declaration_data = Core.Name "data" - -_Declaration_type = Core.Name "type" - -_Declaration_valueBinding = Core.Name "valueBinding" - -_Declaration_typedBinding = Core.Name "typedBinding" - --- | The left-hand side of a declaration -data DeclarationHead = - -- | An application-style declaration head - DeclarationHeadApplication ApplicationDeclarationHead | - -- | A parenthesized declaration head - DeclarationHeadParens DeclarationHead | - -- | A simple name - DeclarationHeadSimple Name - deriving (Eq, Ord, Read, Show) - -_DeclarationHead = Core.Name "hydra.ext.haskell.syntax.DeclarationHead" - -_DeclarationHead_application = Core.Name "application" - -_DeclarationHead_parens = Core.Name "parens" - -_DeclarationHead_simple = Core.Name "simple" - --- | An application-style declaration head -data ApplicationDeclarationHead = - ApplicationDeclarationHead { - -- | The function being applied - applicationDeclarationHeadFunction :: DeclarationHead, - -- | The type variable operand - applicationDeclarationHeadOperand :: Variable} - deriving (Eq, Ord, Read, Show) - -_ApplicationDeclarationHead = Core.Name "hydra.ext.haskell.syntax.ApplicationDeclarationHead" - -_ApplicationDeclarationHead_function = Core.Name "function" - -_ApplicationDeclarationHead_operand = Core.Name "operand" - --- | A 'deriving' statement -newtype Deriving = - Deriving { - unDeriving :: [Name]} - deriving (Eq, Ord, Read, Show) - -_Deriving = Core.Name "hydra.ext.haskell.syntax.Deriving" - --- | An export statement -data Export = - -- | An exported declaration - ExportDeclaration ImportExportSpec | - -- | An exported module - ExportModule ModuleName - deriving (Eq, Ord, Read, Show) - -_Export = Core.Name "hydra.ext.haskell.syntax.Export" - -_Export_declaration = Core.Name "declaration" - -_Export_module = Core.Name "module" - --- | A data expression -data Expression = - -- | A function application - ExpressionApplication ApplicationExpression | - -- | A case expression - ExpressionCase CaseExpression | - -- | A record constructor expression - ExpressionConstructRecord ConstructRecordExpression | - -- | A 'do' expression - ExpressionDo [Statement] | - -- | An 'if' expression - ExpressionIf IfExpression | - -- | An infix application - ExpressionInfixApplication InfixApplicationExpression | - -- | A literal value - ExpressionLiteral Literal | - -- | A lambda expression - ExpressionLambda LambdaExpression | - -- | A left section expression - ExpressionLeftSection SectionExpression | - -- | A 'let' expression - ExpressionLet LetExpression | - -- | A list expression - ExpressionList [Expression] | - -- | A parenthesized expression - ExpressionParens Expression | - -- | A prefix application - ExpressionPrefixApplication PrefixApplicationExpression | - -- | A right section expression - ExpressionRightSection SectionExpression | - -- | A tuple expression - ExpressionTuple [Expression] | - -- | A type signature expression - ExpressionTypeSignature TypeSignatureExpression | - -- | A record update expression - ExpressionUpdateRecord UpdateRecordExpression | - -- | A variable reference - ExpressionVariable Name - deriving (Eq, Ord, Read, Show) - -_Expression = Core.Name "hydra.ext.haskell.syntax.Expression" - -_Expression_application = Core.Name "application" - -_Expression_case = Core.Name "case" - -_Expression_constructRecord = Core.Name "constructRecord" - -_Expression_do = Core.Name "do" - -_Expression_if = Core.Name "if" - -_Expression_infixApplication = Core.Name "infixApplication" - -_Expression_literal = Core.Name "literal" - -_Expression_lambda = Core.Name "lambda" - -_Expression_leftSection = Core.Name "leftSection" - -_Expression_let = Core.Name "let" - -_Expression_list = Core.Name "list" - -_Expression_parens = Core.Name "parens" - -_Expression_prefixApplication = Core.Name "prefixApplication" - -_Expression_rightSection = Core.Name "rightSection" - -_Expression_tuple = Core.Name "tuple" - -_Expression_typeSignature = Core.Name "typeSignature" - -_Expression_updateRecord = Core.Name "updateRecord" - -_Expression_variable = Core.Name "variable" - --- | An application expression -data ApplicationExpression = - ApplicationExpression { - -- | The function being applied - applicationExpressionFunction :: Expression, - -- | The argument - applicationExpressionArgument :: Expression} - deriving (Eq, Ord, Read, Show) - -_ApplicationExpression = Core.Name "hydra.ext.haskell.syntax.ApplicationExpression" - -_ApplicationExpression_function = Core.Name "function" - -_ApplicationExpression_argument = Core.Name "argument" - --- | A case expression -data CaseExpression = - CaseExpression { - -- | The expression being matched - caseExpressionCase :: Expression, - -- | The pattern-matching alternatives - caseExpressionAlternatives :: [Alternative]} - deriving (Eq, Ord, Read, Show) - -_CaseExpression = Core.Name "hydra.ext.haskell.syntax.CaseExpression" - -_CaseExpression_case = Core.Name "case" - -_CaseExpression_alternatives = Core.Name "alternatives" - --- | A record constructor expression -data ConstructRecordExpression = - ConstructRecordExpression { - -- | The constructor name - constructRecordExpressionName :: Name, - -- | The field assignments - constructRecordExpressionFields :: [FieldUpdate]} - deriving (Eq, Ord, Read, Show) - -_ConstructRecordExpression = Core.Name "hydra.ext.haskell.syntax.ConstructRecordExpression" - -_ConstructRecordExpression_name = Core.Name "name" - -_ConstructRecordExpression_fields = Core.Name "fields" - --- | An 'if' expression -data IfExpression = - IfExpression { - -- | The condition expression - ifExpressionCondition :: Expression, - -- | The 'then' branch - ifExpressionThen :: Expression, - -- | The 'else' branch - ifExpressionElse :: Expression} - deriving (Eq, Ord, Read, Show) - -_IfExpression = Core.Name "hydra.ext.haskell.syntax.IfExpression" - -_IfExpression_condition = Core.Name "condition" - -_IfExpression_then = Core.Name "then" - -_IfExpression_else = Core.Name "else" - --- | An infix application expression -data InfixApplicationExpression = - InfixApplicationExpression { - -- | The left-hand operand - infixApplicationExpressionLhs :: Expression, - -- | The infix operator - infixApplicationExpressionOperator :: Operator, - -- | The right-hand operand - infixApplicationExpressionRhs :: Expression} - deriving (Eq, Ord, Read, Show) - -_InfixApplicationExpression = Core.Name "hydra.ext.haskell.syntax.InfixApplicationExpression" - -_InfixApplicationExpression_lhs = Core.Name "lhs" - -_InfixApplicationExpression_operator = Core.Name "operator" - -_InfixApplicationExpression_rhs = Core.Name "rhs" - --- | A lambda expression -data LambdaExpression = - LambdaExpression { - -- | The patterns binding parameters - lambdaExpressionBindings :: [Pattern], - -- | The body of the lambda - lambdaExpressionInner :: Expression} - deriving (Eq, Ord, Read, Show) - -_LambdaExpression = Core.Name "hydra.ext.haskell.syntax.LambdaExpression" - -_LambdaExpression_bindings = Core.Name "bindings" - -_LambdaExpression_inner = Core.Name "inner" - --- | A 'let' expression -data LetExpression = - LetExpression { - -- | The local bindings - letExpressionBindings :: [LocalBinding], - -- | The body of the let expression - letExpressionInner :: Expression} - deriving (Eq, Ord, Read, Show) - -_LetExpression = Core.Name "hydra.ext.haskell.syntax.LetExpression" - -_LetExpression_bindings = Core.Name "bindings" - -_LetExpression_inner = Core.Name "inner" - --- | A prefix expression -data PrefixApplicationExpression = - PrefixApplicationExpression { - -- | The prefix operator - prefixApplicationExpressionOperator :: Operator, - -- | The operand - prefixApplicationExpressionRhs :: Expression} - deriving (Eq, Ord, Read, Show) - -_PrefixApplicationExpression = Core.Name "hydra.ext.haskell.syntax.PrefixApplicationExpression" - -_PrefixApplicationExpression_operator = Core.Name "operator" - -_PrefixApplicationExpression_rhs = Core.Name "rhs" - --- | A section expression -data SectionExpression = - SectionExpression { - -- | The operator - sectionExpressionOperator :: Operator, - -- | The operand - sectionExpressionExpression :: Expression} - deriving (Eq, Ord, Read, Show) - -_SectionExpression = Core.Name "hydra.ext.haskell.syntax.SectionExpression" - -_SectionExpression_operator = Core.Name "operator" - -_SectionExpression_expression = Core.Name "expression" - --- | A type signature expression -data TypeSignatureExpression = - TypeSignatureExpression { - -- | The expression being typed - typeSignatureExpressionInner :: Expression, - -- | The type signature - typeSignatureExpressionType :: Type} - deriving (Eq, Ord, Read, Show) - -_TypeSignatureExpression = Core.Name "hydra.ext.haskell.syntax.TypeSignatureExpression" - -_TypeSignatureExpression_inner = Core.Name "inner" - -_TypeSignatureExpression_type = Core.Name "type" - --- | An update record expression -data UpdateRecordExpression = - UpdateRecordExpression { - -- | The record being updated - updateRecordExpressionInner :: Expression, - -- | The field updates - updateRecordExpressionFields :: [FieldUpdate]} - deriving (Eq, Ord, Read, Show) - -_UpdateRecordExpression = Core.Name "hydra.ext.haskell.syntax.UpdateRecordExpression" - -_UpdateRecordExpression_inner = Core.Name "inner" - -_UpdateRecordExpression_fields = Core.Name "fields" - --- | A field (name/type pair) -data Field = - Field { - -- | The field name - fieldName :: Name, - -- | The field type - fieldType :: Type} - deriving (Eq, Ord, Read, Show) - -_Field = Core.Name "hydra.ext.haskell.syntax.Field" - -_Field_name = Core.Name "name" - -_Field_type = Core.Name "type" - --- | A field together with any comments -data FieldWithComments = - FieldWithComments { - -- | The field - fieldWithCommentsField :: Field, - -- | Optional comments - fieldWithCommentsComments :: (Maybe String)} - deriving (Eq, Ord, Read, Show) - -_FieldWithComments = Core.Name "hydra.ext.haskell.syntax.FieldWithComments" - -_FieldWithComments_field = Core.Name "field" - -_FieldWithComments_comments = Core.Name "comments" - --- | A field name and value -data FieldUpdate = - FieldUpdate { - -- | The field name - fieldUpdateName :: Name, - -- | The field value - fieldUpdateValue :: Expression} - deriving (Eq, Ord, Read, Show) - -_FieldUpdate = Core.Name "hydra.ext.haskell.syntax.FieldUpdate" - -_FieldUpdate_name = Core.Name "name" - -_FieldUpdate_value = Core.Name "value" - --- | An import statement -data Import = - Import { - -- | Whether the import is qualified - importQualified :: Bool, - -- | The module being imported - importModule :: ModuleName, - -- | Optional alias for the module - importAs :: (Maybe ModuleName), - -- | Optional import specification - importSpec :: (Maybe SpecImport)} - deriving (Eq, Ord, Read, Show) - -_Import = Core.Name "hydra.ext.haskell.syntax.Import" - -_Import_qualified = Core.Name "qualified" - -_Import_module = Core.Name "module" - -_Import_as = Core.Name "as" - -_Import_spec = Core.Name "spec" - --- | An import specification -data SpecImport = - -- | A list of imports to include - SpecImportList [ImportExportSpec] | - -- | A list of imports to exclude - SpecImportHiding [ImportExportSpec] - deriving (Eq, Ord, Read, Show) - -_SpecImport = Core.Name "hydra.ext.haskell.syntax.SpecImport" - -_SpecImport_list = Core.Name "list" - -_SpecImport_hiding = Core.Name "hiding" - --- | An import modifier ('pattern' or 'type') -data ImportModifier = - ImportModifierPattern | - ImportModifierType - deriving (Eq, Ord, Read, Show) - -_ImportModifier = Core.Name "hydra.ext.haskell.syntax.ImportModifier" - -_ImportModifier_pattern = Core.Name "pattern" - -_ImportModifier_type = Core.Name "type" - --- | An import or export specification -data ImportExportSpec = - ImportExportSpec { - -- | Optional import modifier - importExportSpecModifier :: (Maybe ImportModifier), - -- | The name being imported or exported - importExportSpecName :: Name, - -- | Optional subspecification - importExportSpecSubspec :: (Maybe SubspecImportExportSpec)} - deriving (Eq, Ord, Read, Show) - -_ImportExportSpec = Core.Name "hydra.ext.haskell.syntax.ImportExportSpec" - -_ImportExportSpec_modifier = Core.Name "modifier" - -_ImportExportSpec_name = Core.Name "name" - -_ImportExportSpec_subspec = Core.Name "subspec" - --- | A subspecification within an import/export -data SubspecImportExportSpec = - -- | Import/export all - SubspecImportExportSpecAll | - -- | Import/export specific names - SubspecImportExportSpecList [Name] - deriving (Eq, Ord, Read, Show) - -_SubspecImportExportSpec = Core.Name "hydra.ext.haskell.syntax.SubspecImportExportSpec" - -_SubspecImportExportSpec_all = Core.Name "all" - -_SubspecImportExportSpec_list = Core.Name "list" - --- | A literal value -data Literal = - -- | A character literal - LiteralChar Int | - -- | A double-precision floating point literal - LiteralDouble Double | - -- | A single-precision floating point literal - LiteralFloat Float | - -- | A 32-bit integer literal - LiteralInt Int | - -- | An arbitrary-precision integer literal - LiteralInteger Integer | - -- | A string literal - LiteralString String - deriving (Eq, Ord, Read, Show) - -_Literal = Core.Name "hydra.ext.haskell.syntax.Literal" - -_Literal_char = Core.Name "char" - -_Literal_double = Core.Name "double" - -_Literal_float = Core.Name "float" - -_Literal_int = Core.Name "int" - -_Literal_integer = Core.Name "integer" - -_Literal_string = Core.Name "string" - --- | A local binding -data LocalBinding = - -- | A type signature - LocalBindingSignature TypeSignature | - -- | A value binding - LocalBindingValue ValueBinding - deriving (Eq, Ord, Read, Show) - -_LocalBinding = Core.Name "hydra.ext.haskell.syntax.LocalBinding" - -_LocalBinding_signature = Core.Name "signature" - -_LocalBinding_value = Core.Name "value" - --- | A collection of local bindings -newtype LocalBindings = - LocalBindings { - unLocalBindings :: [LocalBinding]} - deriving (Eq, Ord, Read, Show) - -_LocalBindings = Core.Name "hydra.ext.haskell.syntax.LocalBindings" - --- | A Haskell module -data Module = - Module { - -- | Optional module head - moduleHead :: (Maybe ModuleHead), - -- | Import statements - moduleImports :: [Import], - -- | Module declarations - moduleDeclarations :: [DeclarationWithComments]} - deriving (Eq, Ord, Read, Show) - -_Module = Core.Name "hydra.ext.haskell.syntax.Module" - -_Module_head = Core.Name "head" - -_Module_imports = Core.Name "imports" - -_Module_declarations = Core.Name "declarations" - --- | A module head -data ModuleHead = - ModuleHead { - -- | Optional module-level comments - moduleHeadComments :: (Maybe String), - -- | The module name - moduleHeadName :: ModuleName, - -- | Export list - moduleHeadExports :: [Export]} - deriving (Eq, Ord, Read, Show) - -_ModuleHead = Core.Name "hydra.ext.haskell.syntax.ModuleHead" - -_ModuleHead_comments = Core.Name "comments" - -_ModuleHead_name = Core.Name "name" - -_ModuleHead_exports = Core.Name "exports" - --- | A module name -newtype ModuleName = - ModuleName { - unModuleName :: String} - deriving (Eq, Ord, Read, Show) - -_ModuleName = Core.Name "hydra.ext.haskell.syntax.ModuleName" - --- | A name -data Name = - -- | An implicit name - NameImplicit QualifiedName | - -- | A normal name - NameNormal QualifiedName | - -- | A parenthesized name - NameParens QualifiedName - deriving (Eq, Ord, Read, Show) - -_Name = Core.Name "hydra.ext.haskell.syntax.Name" - -_Name_implicit = Core.Name "implicit" - -_Name_normal = Core.Name "normal" - -_Name_parens = Core.Name "parens" - --- | A component of a qualified name -newtype NamePart = - NamePart { - unNamePart :: String} - deriving (Eq, Ord, Read, Show) - -_NamePart = Core.Name "hydra.ext.haskell.syntax.NamePart" - --- | An operator -data Operator = - -- | A function used as an infix operator - OperatorBacktick QualifiedName | - -- | A normal infix operator - OperatorNormal QualifiedName - deriving (Eq, Ord, Read, Show) - -_Operator = Core.Name "hydra.ext.haskell.syntax.Operator" - -_Operator_backtick = Core.Name "backtick" - -_Operator_normal = Core.Name "normal" - --- | A pattern -data Pattern = - -- | An application pattern - PatternApplication ApplicationPattern | - -- | An 'as' pattern - PatternAs AsPattern | - -- | A list pattern - PatternList [Pattern] | - -- | A literal pattern - PatternLiteral Literal | - -- | A name pattern - PatternName Name | - -- | A parenthesized pattern - PatternParens Pattern | - -- | A record pattern - PatternRecord RecordPattern | - -- | A tuple pattern - PatternTuple [Pattern] | - -- | A typed pattern - PatternTyped TypedPattern | - -- | A wildcard pattern - PatternWildcard - deriving (Eq, Ord, Read, Show) - -_Pattern = Core.Name "hydra.ext.haskell.syntax.Pattern" - -_Pattern_application = Core.Name "application" - -_Pattern_as = Core.Name "as" - -_Pattern_list = Core.Name "list" - -_Pattern_literal = Core.Name "literal" - -_Pattern_name = Core.Name "name" - -_Pattern_parens = Core.Name "parens" - -_Pattern_record = Core.Name "record" - -_Pattern_tuple = Core.Name "tuple" - -_Pattern_typed = Core.Name "typed" - -_Pattern_wildcard = Core.Name "wildcard" - --- | An application pattern -data ApplicationPattern = - ApplicationPattern { - -- | The constructor name - applicationPatternName :: Name, - -- | The pattern arguments - applicationPatternArgs :: [Pattern]} - deriving (Eq, Ord, Read, Show) - -_ApplicationPattern = Core.Name "hydra.ext.haskell.syntax.ApplicationPattern" - -_ApplicationPattern_name = Core.Name "name" - -_ApplicationPattern_args = Core.Name "args" - --- | An 'as' pattern -data AsPattern = - AsPattern { - -- | The bound name - asPatternName :: Name, - -- | The inner pattern - asPatternInner :: Pattern} - deriving (Eq, Ord, Read, Show) - -_AsPattern = Core.Name "hydra.ext.haskell.syntax.AsPattern" - -_AsPattern_name = Core.Name "name" - -_AsPattern_inner = Core.Name "inner" - --- | A record pattern -data RecordPattern = - RecordPattern { - -- | The constructor name - recordPatternName :: Name, - -- | The field patterns - recordPatternFields :: [PatternField]} - deriving (Eq, Ord, Read, Show) - -_RecordPattern = Core.Name "hydra.ext.haskell.syntax.RecordPattern" - -_RecordPattern_name = Core.Name "name" - -_RecordPattern_fields = Core.Name "fields" - --- | A typed pattern -data TypedPattern = - TypedPattern { - -- | The inner pattern - typedPatternInner :: Pattern, - -- | The type annotation - typedPatternType :: Type} - deriving (Eq, Ord, Read, Show) - -_TypedPattern = Core.Name "hydra.ext.haskell.syntax.TypedPattern" - -_TypedPattern_inner = Core.Name "inner" - -_TypedPattern_type = Core.Name "type" - --- | A pattern field -data PatternField = - PatternField { - -- | The field name - patternFieldName :: Name, - -- | The field pattern - patternFieldPattern :: Pattern} - deriving (Eq, Ord, Read, Show) - -_PatternField = Core.Name "hydra.ext.haskell.syntax.PatternField" - -_PatternField_name = Core.Name "name" - -_PatternField_pattern = Core.Name "pattern" - --- | A qualified name -data QualifiedName = - QualifiedName { - -- | The qualifier parts - qualifiedNameQualifiers :: [NamePart], - -- | The unqualified name part - qualifiedNameUnqualified :: NamePart} - deriving (Eq, Ord, Read, Show) - -_QualifiedName = Core.Name "hydra.ext.haskell.syntax.QualifiedName" - -_QualifiedName_qualifiers = Core.Name "qualifiers" - -_QualifiedName_unqualified = Core.Name "unqualified" - --- | A right-hand side of a binding -newtype RightHandSide = - RightHandSide { - unRightHandSide :: Expression} - deriving (Eq, Ord, Read, Show) - -_RightHandSide = Core.Name "hydra.ext.haskell.syntax.RightHandSide" - --- | A do-notation statement -newtype Statement = - Statement { - unStatement :: Expression} - deriving (Eq, Ord, Read, Show) - -_Statement = Core.Name "hydra.ext.haskell.syntax.Statement" - --- | A type expression -data Type = - -- | An application type - TypeApplication ApplicationType | - -- | A context type - TypeCtx ContextType | - -- | A function type - TypeFunction FunctionType | - -- | An infix type - TypeInfix InfixType | - -- | A list type - TypeList Type | - -- | A parenthesized type - TypeParens Type | - -- | A tuple type - TypeTuple [Type] | - -- | A type variable or type name - TypeVariable Name - deriving (Eq, Ord, Read, Show) - -_Type = Core.Name "hydra.ext.haskell.syntax.Type" - -_Type_application = Core.Name "application" - -_Type_ctx = Core.Name "ctx" - -_Type_function = Core.Name "function" - -_Type_infix = Core.Name "infix" - -_Type_list = Core.Name "list" - -_Type_parens = Core.Name "parens" - -_Type_tuple = Core.Name "tuple" - -_Type_variable = Core.Name "variable" - --- | An application type -data ApplicationType = - ApplicationType { - -- | The type being applied - applicationTypeContext :: Type, - -- | The type argument - applicationTypeArgument :: Type} - deriving (Eq, Ord, Read, Show) - -_ApplicationType = Core.Name "hydra.ext.haskell.syntax.ApplicationType" - -_ApplicationType_context = Core.Name "context" - -_ApplicationType_argument = Core.Name "argument" - --- | A type with a context (type class constraints) -data ContextType = - ContextType { - -- | The type class context - contextTypeCtx :: Assertion, - -- | The constrained type - contextTypeType :: Type} - deriving (Eq, Ord, Read, Show) - -_ContextType = Core.Name "hydra.ext.haskell.syntax.ContextType" - -_ContextType_ctx = Core.Name "ctx" - -_ContextType_type = Core.Name "type" - --- | A function type -data FunctionType = - FunctionType { - -- | The domain type - functionTypeDomain :: Type, - -- | The codomain type - functionTypeCodomain :: Type} - deriving (Eq, Ord, Read, Show) - -_FunctionType = Core.Name "hydra.ext.haskell.syntax.FunctionType" - -_FunctionType_domain = Core.Name "domain" - -_FunctionType_codomain = Core.Name "codomain" - --- | An infix type application -data InfixType = - InfixType { - -- | The left-hand type - infixTypeLhs :: Type, - -- | The type operator - infixTypeOperator :: Operator, - -- | The right-hand operator - infixTypeRhs :: Operator} - deriving (Eq, Ord, Read, Show) - -_InfixType = Core.Name "hydra.ext.haskell.syntax.InfixType" - -_InfixType_lhs = Core.Name "lhs" - -_InfixType_operator = Core.Name "operator" - -_InfixType_rhs = Core.Name "rhs" - --- | A type synonym declaration -data TypeDeclaration = - TypeDeclaration { - -- | The declaration head - typeDeclarationName :: DeclarationHead, - -- | The type being defined - typeDeclarationType :: Type} - deriving (Eq, Ord, Read, Show) - -_TypeDeclaration = Core.Name "hydra.ext.haskell.syntax.TypeDeclaration" - -_TypeDeclaration_name = Core.Name "name" - -_TypeDeclaration_type = Core.Name "type" - --- | A type signature -data TypeSignature = - TypeSignature { - -- | The name being typed - typeSignatureName :: Name, - -- | The type - typeSignatureType :: Type} - deriving (Eq, Ord, Read, Show) - -_TypeSignature = Core.Name "hydra.ext.haskell.syntax.TypeSignature" - -_TypeSignature_name = Core.Name "name" - -_TypeSignature_type = Core.Name "type" - --- | A binding with its type signature -data TypedBinding = - TypedBinding { - -- | The type signature - typedBindingTypeSignature :: TypeSignature, - -- | The value binding - typedBindingValueBinding :: ValueBinding} - deriving (Eq, Ord, Read, Show) - -_TypedBinding = Core.Name "hydra.ext.haskell.syntax.TypedBinding" - -_TypedBinding_typeSignature = Core.Name "typeSignature" - -_TypedBinding_valueBinding = Core.Name "valueBinding" - --- | A value binding -data ValueBinding = - -- | A simple value binding - ValueBindingSimple SimpleValueBinding - deriving (Eq, Ord, Read, Show) - -_ValueBinding = Core.Name "hydra.ext.haskell.syntax.ValueBinding" - -_ValueBinding_simple = Core.Name "simple" - --- | A simple value binding -data SimpleValueBinding = - SimpleValueBinding { - -- | The pattern being bound - simpleValueBindingPattern :: Pattern, - -- | The right-hand side - simpleValueBindingRhs :: RightHandSide, - -- | Optional local bindings (where clause) - simpleValueBindingLocalBindings :: (Maybe LocalBindings)} - deriving (Eq, Ord, Read, Show) - -_SimpleValueBinding = Core.Name "hydra.ext.haskell.syntax.SimpleValueBinding" - -_SimpleValueBinding_pattern = Core.Name "pattern" - -_SimpleValueBinding_rhs = Core.Name "rhs" - -_SimpleValueBinding_localBindings = Core.Name "localBindings" - --- | A type variable -newtype Variable = - Variable { - unVariable :: Name} - deriving (Eq, Ord, Read, Show) - -_Variable = Core.Name "hydra.ext.haskell.syntax.Variable" diff --git a/src/gen-main/haskell/Hydra/Ext/Haskell/Testing.hs b/src/gen-main/haskell/Hydra/Ext/Haskell/Testing.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Ext/Haskell/Testing.hs +++ /dev/null @@ -1,344 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Haskell test code generation codec for HSpec-based generation tests - -module Hydra.Ext.Haskell.Testing where - -import qualified Hydra.Coders as Coders -import qualified Hydra.Constants as Constants -import qualified Hydra.Context as Context -import qualified Hydra.Core as Core -import qualified Hydra.Decode.Core as Core_ -import qualified Hydra.Ext.Haskell.Coder as Coder -import qualified Hydra.Ext.Haskell.Serde as Serde -import qualified Hydra.Ext.Haskell.Syntax as Syntax -import qualified Hydra.Ext.Haskell.Utils as Utils -import qualified Hydra.Formatting as Formatting -import qualified Hydra.Graph as Graph -import qualified Hydra.Inference as Inference -import qualified Hydra.Lexical as Lexical -import qualified Hydra.Lib.Eithers as Eithers -import qualified Hydra.Lib.Equality as Equality -import qualified Hydra.Lib.Lists as Lists -import qualified Hydra.Lib.Literals as Literals -import qualified Hydra.Lib.Logic as Logic -import qualified Hydra.Lib.Maps as Maps -import qualified Hydra.Lib.Math as Math -import qualified Hydra.Lib.Maybes as Maybes -import qualified Hydra.Lib.Pairs as Pairs -import qualified Hydra.Lib.Sets as Sets -import qualified Hydra.Lib.Strings as Strings -import qualified Hydra.Module as Module -import qualified Hydra.Names as Names -import qualified Hydra.Rewriting as Rewriting -import qualified Hydra.Schemas as Schemas -import qualified Hydra.Serialization as Serialization -import qualified Hydra.Show.Errors as Errors -import qualified Hydra.Substitution as Substitution -import qualified Hydra.Testing as Testing -import qualified Hydra.Typing as Typing -import qualified Hydra.Util as Util -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | Add namespaces from a set of names to existing namespaces -addNamespacesToNamespaces :: Module.Namespaces Syntax.ModuleName -> S.Set Core.Name -> Module.Namespaces Syntax.ModuleName -addNamespacesToNamespaces ns0 names = - - let newNamespaces = Sets.fromList (Maybes.cat (Lists.map Names.namespaceOf (Sets.toList names))) - toModuleName = - \namespace -> Syntax.ModuleName (Formatting.capitalize (Lists.last (Strings.splitOn "." (Module.unNamespace namespace)))) - newMappings = Maps.fromList (Lists.map (\ns_ -> (ns_, (toModuleName ns_))) (Sets.toList newNamespaces)) - in Module.Namespaces { - Module.namespacesFocus = (Module.namespacesFocus ns0), - Module.namespacesMapping = (Maps.union (Module.namespacesMapping ns0) newMappings)} - --- | Build namespaces for a test group including encoded term references -buildNamespacesForTestGroup :: Module.Module -> Testing.TestGroup -> Graph.Graph -> Either String (Module.Namespaces Syntax.ModuleName) -buildNamespacesForTestGroup mod tgroup graph_ = - - let testCases_ = collectTestCases tgroup - testTerms = Lists.concat (Lists.map extractTestTerms testCases_) - testBindings = - Lists.map (\term -> Core.Binding { - Core.bindingName = (Core.Name "_test_"), - Core.bindingTerm = term, - Core.bindingType = Nothing}) testTerms - tempModule = - Module.Module { - Module.moduleNamespace = (Module.moduleNamespace mod), - Module.moduleDefinitions = (Lists.map (\b -> Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.bindingName b), - Module.termDefinitionTerm = (Core.bindingTerm b), - Module.termDefinitionType = (Core.bindingType b)})) testBindings), - Module.moduleTermDependencies = (Module.moduleTermDependencies mod), - Module.moduleTypeDependencies = (Module.moduleTypeDependencies mod), - Module.moduleDescription = (Module.moduleDescription mod)} - in (Eithers.bind (Eithers.bimap (\ic -> Errors.error (Context.inContextObject ic)) (\a -> a) (Utils.namespacesForModule tempModule Lexical.emptyContext graph_)) (\baseNamespaces -> - let encodedNames = Sets.unions (Lists.map (\t -> extractEncodedTermVariableNames graph_ t) testTerms) - in (Right (addNamespacesToNamespaces baseNamespaces encodedNames)))) - --- | Build the complete test module using a TestCodec -buildTestModuleWithCodec :: Testing.TestCodec -> Module.Module -> Testing.TestGroup -> String -> t0 -> String -buildTestModuleWithCodec codec testModule testGroup testBody namespaces = - - let ns_ = Module.moduleNamespace testModule - specNs = Module.Namespace (Strings.cat2 (Module.unNamespace ns_) "Spec") - moduleNameString = Testing.testCodecFormatModuleName codec specNs - groupName_ = Testing.testGroupName testGroup - domainImports = Testing.testCodecFindImports codec Sets.empty - standardImports = - [ - "import Hydra.Kernel", - "import qualified Test.Hspec as H", - "import qualified Data.List as L", - "import qualified Data.Map as M", - "import qualified Data.Set as S", - "import qualified Data.Maybe as Y"] - allImports = Lists.concat2 standardImports domainImports - debugComments = - [ - "-- DEBUG: Focus namespace = (see generated module)", - "-- DEBUG: Namespace mappings: (see generated module)"] - header = - Strings.intercalate "\n" (Lists.concat [ - [ - Strings.cat2 "-- " Constants.warningAutoGeneratedFile, - ""], - debugComments, - [ - "", - (Strings.cat [ - "module ", - moduleNameString, - " where"]), - ""], - allImports, - [ - "", - "spec :: H.Spec", - (Strings.cat [ - "spec = H.describe ", - (Literals.showString groupName_), - " $ do"])]]) - in (Strings.cat [ - header, - "\n", - testBody, - "\n"]) - --- | Collect variable names from encoded terms within a single term node -collectNames :: Graph.Graph -> S.Set Core.Name -> Core.Term -> S.Set Core.Name -collectNames graf names t = - Logic.ifElse (Schemas.isEncodedTerm (Rewriting.deannotateTerm t)) (Eithers.either (\_ -> names) (\decodedTerm -> Sets.union names (Rewriting.termDependencyNames True True True decodedTerm)) (Eithers.bimap (\_e -> _e) (\_a -> _a) (Core_.term graf t))) names - --- | Collect all test cases from a test group recursively -collectTestCases :: Testing.TestGroup -> [Testing.TestCaseWithMetadata] -collectTestCases tg = - Lists.concat2 (Testing.testGroupCases tg) (Lists.concat (Lists.map collectTestCases (Testing.testGroupSubgroups tg))) - --- | Check if a term contains any trivially polymorphic sub-terms -containsTriviallyPolymorphic :: Core.Term -> Bool -containsTriviallyPolymorphic term = - case term of - Core.TermList v0 -> Logic.or (Lists.null v0) (Lists.foldl Logic.or False (Lists.map containsTriviallyPolymorphic v0)) - Core.TermSet v0 -> Logic.or (Sets.null v0) (Lists.foldl Logic.or False (Lists.map containsTriviallyPolymorphic (Sets.toList v0))) - Core.TermMap v0 -> Logic.or (Maps.null v0) (Logic.or (Lists.foldl Logic.or False (Lists.map containsTriviallyPolymorphic (Maps.keys v0))) (Lists.foldl Logic.or False (Lists.map containsTriviallyPolymorphic (Lists.map (\p -> Pairs.second p) (Maps.toList v0))))) - Core.TermMaybe v0 -> Maybes.maybe True containsTriviallyPolymorphic v0 - Core.TermEither _ -> True - Core.TermUnion v0 -> containsTriviallyPolymorphic (Core.fieldTerm (Core.injectionField v0)) - Core.TermPair v0 -> Logic.or (containsTriviallyPolymorphic (Pairs.first v0)) (containsTriviallyPolymorphic (Pairs.second v0)) - Core.TermRecord v0 -> Lists.foldl Logic.or False (Lists.map (\f -> containsTriviallyPolymorphic (Core.fieldTerm f)) (Core.recordFields v0)) - Core.TermApplication v0 -> Logic.or (containsTriviallyPolymorphic (Core.applicationFunction v0)) (containsTriviallyPolymorphic (Core.applicationArgument v0)) - _ -> False - --- | Extract all variable names from term-encoded terms in a given term -extractEncodedTermVariableNames :: Graph.Graph -> Core.Term -> S.Set Core.Name -extractEncodedTermVariableNames graf term = - Rewriting.foldOverTerm Coders.TraversalOrderPre (collectNames graf) Sets.empty term - --- | Extract input and output terms from a test case -extractTestTerms :: Testing.TestCaseWithMetadata -> [Core.Term] -extractTestTerms tcm = - case (Testing.testCaseWithMetadataCase tcm) of - Testing.TestCaseDelegatedEvaluation v0 -> [ - Testing.delegatedEvaluationTestCaseInput v0, - (Testing.delegatedEvaluationTestCaseOutput v0)] - _ -> [] - --- | Find necessary imports for Haskell based on referenced names -findHaskellImports :: Module.Namespaces Syntax.ModuleName -> t0 -> [String] -findHaskellImports namespaces names_ = - - let mapping_ = Module.namespacesMapping namespaces - filtered = - Maps.filterWithKey (\ns_ -> \_v -> Logic.not (Equality.equal (Lists.head (Strings.splitOn "hydra.test." (Module.unNamespace ns_))) "")) mapping_ - in (Lists.map (\entry -> Strings.cat [ - "import qualified ", - (Strings.intercalate "." (Lists.map Formatting.capitalize (Strings.splitOn "." (Module.unNamespace (Pairs.first entry))))), - " as ", - (Syntax.unModuleName (Pairs.second entry))]) (Maps.toList filtered)) - --- | Generate a Haskell test file for a test group, with type inference and namespace building -generateHaskellTestFile :: Module.Module -> Testing.TestGroup -> Graph.Graph -> Either String (String, String) -generateHaskellTestFile testModule testGroup g = - Eithers.bind (buildNamespacesForTestGroup testModule testGroup g) (\namespaces -> generateTestFileWithCodec (haskellTestCodec namespaces) testModule testGroup namespaces g) - --- | Generate a single test case using a TestCodec -generateTestCaseWithCodec :: Graph.Graph -> Module.Namespaces Syntax.ModuleName -> Testing.TestCodec -> Int -> Testing.TestCaseWithMetadata -> Either String [String] -generateTestCaseWithCodec g namespaces codec depth tcm = - - let name_ = Testing.testCaseWithMetadataName tcm - tcase = Testing.testCaseWithMetadataCase tcm - in case tcase of - Testing.TestCaseDelegatedEvaluation v0 -> - let input_ = Testing.delegatedEvaluationTestCaseInput v0 - output_ = Testing.delegatedEvaluationTestCaseOutput v0 - formattedName = Testing.testCodecFormatTestName codec name_ - continuationIndent = Math.add (Math.mul depth 2) 4 - in (Eithers.bind (Testing.testCodecEncodeTerm codec input_ g) (\inputCode -> Eithers.bind (Testing.testCodecEncodeTerm codec output_ g) (\outputCode -> Eithers.bind (generateTypeAnnotationFor g namespaces input_ output_) (\typeAnnotation -> - let indentedInputCode = indentContinuationLines continuationIndent inputCode - indentedOutputCode = indentContinuationLines continuationIndent outputCode - finalOutputCode = Maybes.maybe indentedOutputCode (\anno -> Strings.cat2 indentedOutputCode anno) typeAnnotation - in (Right [ - Strings.cat [ - "H.it ", - (Literals.showString formattedName), - " $ H.shouldBe"], - (Strings.cat [ - " (", - indentedInputCode, - ")"]), - (Strings.cat [ - " (", - finalOutputCode, - ")"])]))))) - _ -> Right [] - --- | Generate a complete test file using a TestCodec -generateTestFileWithCodec :: Testing.TestCodec -> Module.Module -> Testing.TestGroup -> Module.Namespaces Syntax.ModuleName -> Graph.Graph -> Either String (String, String) -generateTestFileWithCodec codec testModule testGroup namespaces g = - Eithers.map (\testBody -> - let testModuleContent = buildTestModuleWithCodec codec testModule testGroup testBody namespaces - ext = Module.unFileExtension (Testing.testCodecFileExtension codec) - ns_ = Module.moduleNamespace testModule - specNs = Module.Namespace (Strings.cat2 (Module.unNamespace ns_) "Spec") - filePath = Names.namespaceToFilePath Util.CaseConventionPascal (Module.FileExtension ext) specNs - in (filePath, testModuleContent)) (generateTestGroupHierarchy g namespaces codec 1 testGroup) - --- | Generate test hierarchy preserving the structure with H.describe blocks for subgroups -generateTestGroupHierarchy :: Graph.Graph -> Module.Namespaces Syntax.ModuleName -> Testing.TestCodec -> Int -> Testing.TestGroup -> Either String String -generateTestGroupHierarchy g namespaces codec depth testGroup = - - let cases_ = Testing.testGroupCases testGroup - subgroups = Testing.testGroupSubgroups testGroup - indent = Strings.fromList (Lists.replicate (Math.mul depth 2) 32) - in (Eithers.bind (Eithers.mapList (\tc -> generateTestCaseWithCodec g namespaces codec depth tc) cases_) (\testCaseLinesRaw -> - let testCaseLines = Lists.map (\lines_ -> Lists.map (\line -> Strings.cat2 indent line) lines_) testCaseLinesRaw - testCasesStr = Strings.intercalate "\n" (Lists.concat testCaseLines) - in (Eithers.map (\subgroupsStr -> Strings.cat [ - testCasesStr, - (Logic.ifElse (Logic.or (Equality.equal testCasesStr "") (Equality.equal subgroupsStr "")) "" "\n"), - subgroupsStr]) (Eithers.map (\blocks -> Strings.intercalate "\n" blocks) (Eithers.mapList (\subgroup -> - let groupName_ = Testing.testGroupName subgroup - in (Eithers.map (\content -> Strings.cat [ - indent, - "H.describe ", - (Literals.showString groupName_), - " $ do\n", - content]) (generateTestGroupHierarchy g namespaces codec (Math.add depth 1) subgroup))) subgroups))))) - --- | Generate a type annotation for polymorphic output values -generateTypeAnnotationFor :: Graph.Graph -> Module.Namespaces Syntax.ModuleName -> Core.Term -> Core.Term -> Either String (Maybe String) -generateTypeAnnotationFor g namespaces inputTerm outputTerm = - Logic.ifElse (Logic.not (containsTriviallyPolymorphic outputTerm)) (Right Nothing) (Maybes.maybe (Right Nothing) (\result -> - let typeScheme = Pairs.second result - typ = Core.typeSchemeType typeScheme - schemaVars = Sets.fromList (Maps.keys (Graph.graphSchemaTypes g)) - freeVars = Sets.toList (Sets.difference (Rewriting.freeVariablesInType typ) schemaVars) - isEither = - case (Rewriting.deannotateTerm outputTerm) of - Core.TermEither _ -> True - _ -> False - in (Logic.ifElse (Logic.or isEither (Logic.not (Lists.null freeVars))) ( - let int32Type = Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32) - subst = Typing.TypeSubst (Maps.fromList (Lists.map (\v -> (v, int32Type)) freeVars)) - groundedType = Substitution.substInType subst typ - in (Eithers.map (\typeStr -> Just (Strings.cat2 " :: " typeStr)) (typeToHaskell namespaces groundedType g))) (Right Nothing))) (tryInferTypeOf g inputTerm)) - --- | Template for Haskell import statements -haskellImportTemplate :: String -haskellImportTemplate = "import qualified {namespace} as {alias}" - --- | Template for Haskell test module structure -haskellModuleTemplate :: String -haskellModuleTemplate = - Strings.intercalate "\n" [ - Strings.cat2 "-- " Constants.warningAutoGeneratedFile, - "", - "module {moduleName} where", - "", - "{imports}", - "", - "spec :: H.Spec", - "{testGroup}", - "{testCases}", - ""] - --- | Template for HSpec test case assertions -haskellTestCaseTemplate :: String -haskellTestCaseTemplate = - Strings.intercalate "\n" [ - " H.it {name} $ H.shouldBe", - " ({input})", - " ({output})", - ""] - --- | Create a Haskell TestCodec that uses the real Haskell coder -haskellTestCodec :: Module.Namespaces Syntax.ModuleName -> Testing.TestCodec -haskellTestCodec namespaces = - Testing.TestCodec { - Testing.testCodecLanguage = (Coders.LanguageName "haskell"), - Testing.testCodecFileExtension = (Module.FileExtension "hs"), - Testing.testCodecEncodeTerm = (termToHaskell namespaces), - Testing.testCodecEncodeType = (typeToHaskell namespaces), - Testing.testCodecFormatTestName = (\n -> n), - Testing.testCodecFormatModuleName = namespaceToModuleName, - Testing.testCodecTestCaseTemplate = haskellTestCaseTemplate, - Testing.testCodecTestGroupTemplate = haskellTestGroupTemplate, - Testing.testCodecModuleTemplate = haskellModuleTemplate, - Testing.testCodecImportTemplate = haskellImportTemplate, - Testing.testCodecFindImports = (findHaskellImports namespaces)} - --- | Template for HSpec test group description -haskellTestGroupTemplate :: String -haskellTestGroupTemplate = "spec = H.describe {groupName} $ do" - --- | Indent continuation lines of a multi-line string -indentContinuationLines :: Int -> String -> String -indentContinuationLines n s = - Strings.intercalate (Strings.cat2 "\n" (Strings.fromList (Lists.replicate n 32))) (Strings.splitOn "\n" s) - --- | Convert namespace to Haskell module name -namespaceToModuleName :: Module.Namespace -> String -namespaceToModuleName ns_ = - Strings.intercalate "." (Lists.map Formatting.capitalize (Strings.splitOn "." (Module.unNamespace ns_))) - --- | Convert a Hydra term to a Haskell expression string -termToHaskell :: Module.Namespaces Syntax.ModuleName -> Core.Term -> Graph.Graph -> Either String String -termToHaskell namespaces term g = - Eithers.bimap (\ic -> Errors.error (Context.inContextObject ic)) (\arg_ -> (\arg_ -> Serialization.printExpr (Serialization.parenthesize arg_)) (Serde.expressionToExpr arg_)) (Coder.encodeTerm 0 namespaces term Lexical.emptyContext g) - --- | Try to infer the type of a term, returning Nothing if inference fails -tryInferTypeOf :: Graph.Graph -> Core.Term -> Maybe (Core.Term, Core.TypeScheme) -tryInferTypeOf g term = - Eithers.either (\_ -> Nothing) (\result -> Just (Pairs.first result)) (Inference.inferTypeOf Lexical.emptyContext g term) - --- | Convert a Hydra type to a Haskell type expression string -typeToHaskell :: Module.Namespaces Syntax.ModuleName -> Core.Type -> t0 -> Either String String -typeToHaskell namespaces typ g = - Eithers.bimap (\ic -> Errors.error (Context.inContextObject ic)) (\arg_ -> (\arg_ -> Serialization.printExpr (Serialization.parenthesize arg_)) (Serde.typeToExpr arg_)) (Coder.encodeType namespaces typ Lexical.emptyContext g) diff --git a/src/gen-main/haskell/Hydra/Ext/Haskell/Utils.hs b/src/gen-main/haskell/Hydra/Ext/Haskell/Utils.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Ext/Haskell/Utils.hs +++ /dev/null @@ -1,219 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Utilities for working with Haskell syntax trees - -module Hydra.Ext.Haskell.Utils where - -import qualified Hydra.Context as Context -import qualified Hydra.Core as Core -import qualified Hydra.Errors as Errors -import qualified Hydra.Ext.Haskell.Language as Language -import qualified Hydra.Ext.Haskell.Syntax as Syntax -import qualified Hydra.Formatting as Formatting -import qualified Hydra.Graph as Graph -import qualified Hydra.Lib.Eithers as Eithers -import qualified Hydra.Lib.Equality as Equality -import qualified Hydra.Lib.Lists as Lists -import qualified Hydra.Lib.Logic as Logic -import qualified Hydra.Lib.Maps as Maps -import qualified Hydra.Lib.Maybes as Maybes -import qualified Hydra.Lib.Pairs as Pairs -import qualified Hydra.Lib.Sets as Sets -import qualified Hydra.Lib.Strings as Strings -import qualified Hydra.Module as Module -import qualified Hydra.Names as Names -import qualified Hydra.Rewriting as Rewriting -import qualified Hydra.Schemas as Schemas -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | Create an application pattern from a name and argument patterns -applicationPattern :: Syntax.Name -> [Syntax.Pattern] -> Syntax.Pattern -applicationPattern name args = - Syntax.PatternApplication (Syntax.ApplicationPattern { - Syntax.applicationPatternName = name, - Syntax.applicationPatternArgs = args}) - --- | Generate a Haskell name reference for a Hydra element -elementReference :: Module.Namespaces Syntax.ModuleName -> Core.Name -> Syntax.Name -elementReference namespaces name = - - let namespacePair = Module.namespacesFocus namespaces - gname = Pairs.first namespacePair - gmod = Syntax.unModuleName (Pairs.second namespacePair) - namespacesMap = Module.namespacesMapping namespaces - qname = Names.qualifyName name - local = Module.qualifiedNameLocal qname - escLocal = sanitizeHaskellName local - mns = Module.qualifiedNameNamespace qname - in (Maybes.cases (Module.qualifiedNameNamespace qname) (simpleName local) (\ns -> Maybes.cases (Maps.lookup ns namespacesMap) (simpleName local) (\mn -> - let aliasStr = Syntax.unModuleName mn - in (Logic.ifElse (Equality.equal ns gname) (simpleName escLocal) (rawName (Strings.cat [ - aliasStr, - ".", - (sanitizeHaskellName local)])))))) - --- | Create a Haskell function application expression -hsapp :: Syntax.Expression -> Syntax.Expression -> Syntax.Expression -hsapp l r = - Syntax.ExpressionApplication (Syntax.ApplicationExpression { - Syntax.applicationExpressionFunction = l, - Syntax.applicationExpressionArgument = r}) - --- | Create a Haskell lambda expression -hslambda :: Syntax.Name -> Syntax.Expression -> Syntax.Expression -hslambda name rhs = - Syntax.ExpressionLambda (Syntax.LambdaExpression { - Syntax.lambdaExpressionBindings = [ - Syntax.PatternName name], - Syntax.lambdaExpressionInner = rhs}) - --- | Create a Haskell literal expression -hslit :: Syntax.Literal -> Syntax.Expression -hslit lit = Syntax.ExpressionLiteral lit - --- | Create a Haskell variable expression from a string -hsvar :: String -> Syntax.Expression -hsvar s = Syntax.ExpressionVariable (rawName s) - --- | Compute the Haskell module namespaces for a Hydra module -namespacesForModule :: Module.Module -> Context.Context -> Graph.Graph -> Either (Context.InContext Errors.Error) (Module.Namespaces Syntax.ModuleName) -namespacesForModule mod cx g = - Eithers.bind (Schemas.moduleDependencyNamespaces cx g True True True True mod) (\nss -> - let ns = Module.moduleNamespace mod - toModuleName = - \namespace -> - let namespaceStr = Module.unNamespace namespace - parts = Strings.splitOn "." namespaceStr - lastPart = Lists.last parts - capitalized = Formatting.capitalize lastPart - in (Syntax.ModuleName capitalized) - toPair = \name -> (name, (toModuleName name)) - addPair = - \state -> \namePair -> - let currentMap = Pairs.first state - currentSet = Pairs.second state - name = Pairs.first namePair - alias = Pairs.second namePair - aliasStr = Syntax.unModuleName alias - in (Logic.ifElse (Sets.member alias currentSet) (addPair state (name, (Syntax.ModuleName (Strings.cat2 aliasStr "_")))) (Maps.insert name alias currentMap, (Sets.insert alias currentSet))) - focusPair = toPair ns - nssAsList = Sets.toList nss - nssPairs = Lists.map toPair nssAsList - emptyState = (Maps.empty, Sets.empty) - finalState = Lists.foldl addPair emptyState nssPairs - resultMap = Pairs.first finalState - in (Right (Module.Namespaces { - Module.namespacesFocus = focusPair, - Module.namespacesMapping = resultMap}))) - --- | Generate an accessor name for a newtype wrapper (e.g., 'unFoo' for Foo) -newtypeAccessorName :: Core.Name -> String -newtypeAccessorName name = Strings.cat2 "un" (Names.localNameOf name) - --- | Create a raw Haskell name from a string without sanitization -rawName :: String -> Syntax.Name -rawName n = - Syntax.NameNormal (Syntax.QualifiedName { - Syntax.qualifiedNameQualifiers = [], - Syntax.qualifiedNameUnqualified = (Syntax.NamePart n)}) - --- | Generate a Haskell name for a record field accessor -recordFieldReference :: Module.Namespaces Syntax.ModuleName -> Core.Name -> Core.Name -> Syntax.Name -recordFieldReference namespaces sname fname = - - let fnameStr = Core.unName fname - qname = Names.qualifyName sname - ns = Module.qualifiedNameNamespace qname - typeNameStr = typeNameForRecord sname - decapitalized = Formatting.decapitalize typeNameStr - capitalized = Formatting.capitalize fnameStr - nm = Strings.cat2 decapitalized capitalized - qualName = - Module.QualifiedName { - Module.qualifiedNameNamespace = ns, - Module.qualifiedNameLocal = nm} - unqualName = Names.unqualifyName qualName - in (elementReference namespaces unqualName) - --- | Sanitize a string to be a valid Haskell identifier, escaping reserved words -sanitizeHaskellName :: String -> String -sanitizeHaskellName = Formatting.sanitizeWithUnderscores Language.reservedWords - --- | Create a sanitized Haskell name from a string -simpleName :: String -> Syntax.Name -simpleName arg_ = rawName (sanitizeHaskellName arg_) - --- | Create a simple value binding (e.g., 'foo = expr' or 'foo = expr where ...') -simpleValueBinding :: Syntax.Name -> Syntax.Expression -> Maybe Syntax.LocalBindings -> Syntax.ValueBinding -simpleValueBinding hname rhs bindings = - - let pat = - Syntax.PatternApplication (Syntax.ApplicationPattern { - Syntax.applicationPatternName = hname, - Syntax.applicationPatternArgs = []}) - rightHandSide = Syntax.RightHandSide rhs - in (Syntax.ValueBindingSimple (Syntax.SimpleValueBinding { - Syntax.simpleValueBindingPattern = pat, - Syntax.simpleValueBindingRhs = rightHandSide, - Syntax.simpleValueBindingLocalBindings = bindings})) - --- | Convert a list of types into a nested type application -toTypeApplication :: [Syntax.Type] -> Syntax.Type -toTypeApplication types = - - let app = - \l -> Logic.ifElse (Equality.gt (Lists.length l) 1) (Syntax.TypeApplication (Syntax.ApplicationType { - Syntax.applicationTypeContext = (app (Lists.tail l)), - Syntax.applicationTypeArgument = (Lists.head l)})) (Lists.head l) - in (app (Lists.reverse types)) - --- | Extract the local type name from a fully qualified record type name -typeNameForRecord :: Core.Name -> String -typeNameForRecord sname = - - let snameStr = Core.unName sname - parts = Strings.splitOn "." snameStr - in (Lists.last parts) - --- | Generate a Haskell name for a union variant constructor, with disambiguation -unionFieldReference :: S.Set Core.Name -> Module.Namespaces Syntax.ModuleName -> Core.Name -> Core.Name -> Syntax.Name -unionFieldReference boundNames namespaces sname fname = - - let fnameStr = Core.unName fname - qname = Names.qualifyName sname - ns = Module.qualifiedNameNamespace qname - typeNameStr = typeNameForRecord sname - capitalizedTypeName = Formatting.capitalize typeNameStr - capitalizedFieldName = Formatting.capitalize fnameStr - deconflict = - \name -> - let tname = - Names.unqualifyName (Module.QualifiedName { - Module.qualifiedNameNamespace = ns, - Module.qualifiedNameLocal = name}) - in (Logic.ifElse (Sets.member tname boundNames) (deconflict (Strings.cat2 name "_")) name) - nm = deconflict (Strings.cat2 capitalizedTypeName capitalizedFieldName) - qualName = - Module.QualifiedName { - Module.qualifiedNameNamespace = ns, - Module.qualifiedNameLocal = nm} - unqualName = Names.unqualifyName qualName - in (elementReference namespaces unqualName) - --- | Unpack nested forall types into a list of type variables and the inner type -unpackForallType :: Core.Type -> ([Core.Name], Core.Type) -unpackForallType t = - case (Rewriting.deannotateType t) of - Core.TypeForall v0 -> - let v = Core.forallTypeParameter v0 - tbody = Core.forallTypeBody v0 - recursiveResult = unpackForallType tbody - vars = Pairs.first recursiveResult - finalType = Pairs.second recursiveResult - in (Lists.cons v vars, finalType) - _ -> ([], t) diff --git a/src/gen-main/haskell/Hydra/Ext/Org/Json/Decoding.hs b/src/gen-main/haskell/Hydra/Ext/Org/Json/Decoding.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Ext/Org/Json/Decoding.hs +++ /dev/null @@ -1,55 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Decoding functions for JSON data - -module Hydra.Ext.Org.Json.Decoding where - -import qualified Hydra.Json.Model as Model -import qualified Hydra.Lib.Eithers as Eithers -import qualified Hydra.Lib.Maps as Maps -import qualified Hydra.Lib.Maybes as Maybes -import qualified Hydra.Lib.Strings as Strings -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | Decode a JSON array using a decoder for elements -decodeArray :: (Model.Value -> Either String t0) -> Model.Value -> Either String [t0] -decodeArray decodeElem x = - case x of - Model.ValueArray v0 -> Eithers.mapList decodeElem v0 - _ -> Left "expected an array" - --- | Decode a JSON boolean value -decodeBoolean :: Model.Value -> Either String Bool -decodeBoolean x = - case x of - Model.ValueBoolean v0 -> Right v0 - _ -> Left "expected a boolean" - --- | Decode a required field from a JSON object -decodeField :: (t0 -> Either String t1) -> String -> M.Map String t0 -> Either String t1 -decodeField decodeValue name m = - Eithers.bind (decodeOptionalField decodeValue name m) (Maybes.maybe (Left (Strings.cat2 "missing field: " name)) (\f -> Right f)) - --- | Decode a JSON object value -decodeObject :: Model.Value -> Either String (M.Map String Model.Value) -decodeObject x = - case x of - Model.ValueObject v0 -> Right v0 - _ -> Left "expected an object" - --- | Decode an optional field from a JSON object -decodeOptionalField :: Ord t3 => ((t0 -> Either t1 t2) -> t3 -> M.Map t3 t0 -> Either t1 (Maybe t2)) -decodeOptionalField decodeValue name m = - Maybes.maybe (Right Nothing) (\v -> Eithers.map (\x -> Just x) (decodeValue v)) (Maps.lookup name m) - --- | Decode a JSON string value -decodeString :: Model.Value -> Either String String -decodeString x = - case x of - Model.ValueString v0 -> Right v0 - _ -> Left "expected a string" diff --git a/src/gen-main/haskell/Hydra/Ext/Org/Yaml/Model.hs b/src/gen-main/haskell/Hydra/Ext/Org/Yaml/Model.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Ext/Org/Yaml/Model.hs +++ /dev/null @@ -1,61 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | A basic YAML representation model. Based on: --- | https://yaml.org/spec/1.2/spec.html --- | The Serialization and Presentation properties of YAML, --- | including directives, comments, anchors, style, formatting, and aliases, are not supported by this model. --- | In addition, tags are omitted from this model, and non-standard scalars are unsupported. - -module Hydra.Ext.Org.Yaml.Model where - -import qualified Hydra.Core as Core -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | A YAML node (value) -data Node = - -- | A mapping from nodes to nodes - NodeMapping (M.Map Node Node) | - -- | A scalar value - NodeScalar Scalar | - -- | A sequence of nodes - NodeSequence [Node] - deriving (Eq, Ord, Read, Show) - -_Node = Core.Name "hydra.ext.org.yaml.model.Node" - -_Node_mapping = Core.Name "mapping" - -_Node_scalar = Core.Name "scalar" - -_Node_sequence = Core.Name "sequence" - --- | A union of scalars supported in the YAML failsafe and JSON schemas. Other scalars are not supported here -data Scalar = - -- | Represents a true/false value - ScalarBool Bool | - -- | Represents an approximation to real numbers - ScalarFloat Double | - -- | Represents arbitrary sized finite mathematical integers - ScalarInt Integer | - -- | Represents the lack of a value - ScalarNull | - -- | A string value - ScalarStr String - deriving (Eq, Ord, Read, Show) - -_Scalar = Core.Name "hydra.ext.org.yaml.model.Scalar" - -_Scalar_bool = Core.Name "bool" - -_Scalar_float = Core.Name "float" - -_Scalar_int = Core.Name "int" - -_Scalar_null = Core.Name "null" - -_Scalar_str = Core.Name "str" diff --git a/src/gen-main/haskell/Hydra/Extract/Core.hs b/src/gen-main/haskell/Hydra/Extract/Core.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Extract/Core.hs +++ /dev/null @@ -1,576 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Extraction and validation for hydra.core types - -module Hydra.Extract.Core where - -import qualified Hydra.Context as Context -import qualified Hydra.Core as Core -import qualified Hydra.Errors as Errors -import qualified Hydra.Graph as Graph -import qualified Hydra.Lexical as Lexical -import qualified Hydra.Lib.Eithers as Eithers -import qualified Hydra.Lib.Equality as Equality -import qualified Hydra.Lib.Lists as Lists -import qualified Hydra.Lib.Literals as Literals -import qualified Hydra.Lib.Logic as Logic -import qualified Hydra.Lib.Maps as Maps -import qualified Hydra.Lib.Maybes as Maybes -import qualified Hydra.Lib.Pairs as Pairs -import qualified Hydra.Lib.Strings as Strings -import qualified Hydra.Rewriting as Rewriting -import qualified Hydra.Show.Core as Core_ -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | Extract an arbitrary-precision floating-point value from a term -bigfloat :: Context.Context -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) Double -bigfloat cx graph t = Eithers.bind (literal cx graph t) (\l -> Eithers.bind (floatLiteral cx l) (\f -> bigfloatValue cx f)) - --- | Extract a bigfloat value from a FloatValue -bigfloatValue :: Context.Context -> Core.FloatValue -> Either (Context.InContext Errors.Error) Double -bigfloatValue cx v = - case v of - Core.FloatValueBigfloat v0 -> Right v0 - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "bigfloat") " but found ") (Core_.float v)))), - Context.inContextContext = cx}) - --- | Extract an arbitrary-precision integer value from a term -bigint :: Context.Context -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) Integer -bigint cx graph t = Eithers.bind (literal cx graph t) (\l -> Eithers.bind (integerLiteral cx l) (\i -> bigintValue cx i)) - --- | Extract a bigint value from an IntegerValue -bigintValue :: Context.Context -> Core.IntegerValue -> Either (Context.InContext Errors.Error) Integer -bigintValue cx v = - case v of - Core.IntegerValueBigint v0 -> Right v0 - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "bigint") " but found ") (Core_.integer v)))), - Context.inContextContext = cx}) - --- | Extract a binary data value from a term -binary :: Context.Context -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) B.ByteString -binary cx graph t = Eithers.bind (literal cx graph t) (\l -> binaryLiteral cx l) - --- | Extract a binary literal from a Literal value -binaryLiteral :: Context.Context -> Core.Literal -> Either (Context.InContext Errors.Error) B.ByteString -binaryLiteral cx v = - case v of - Core.LiteralBinary v0 -> Right v0 - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "binary") " but found ") (Core_.literal v)))), - Context.inContextContext = cx}) - --- | Extract a boolean value from a term -boolean :: Context.Context -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) Bool -boolean cx graph t = Eithers.bind (literal cx graph t) (\l -> booleanLiteral cx l) - --- | Extract a boolean literal from a Literal value -booleanLiteral :: Context.Context -> Core.Literal -> Either (Context.InContext Errors.Error) Bool -booleanLiteral cx v = - case v of - Core.LiteralBoolean v0 -> Right v0 - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "boolean") " but found ") (Core_.literal v)))), - Context.inContextContext = cx}) - --- | Extract a specific case handler from a case statement term -caseField :: Context.Context -> Core.Name -> String -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) Core.Field -caseField cx name n graph term = - - let fieldName = Core.Name n - in (Eithers.bind (cases cx name graph term) (\cs -> - let matching = - Lists.filter (\f -> Equality.equal (Core.unName (Core.fieldName f)) (Core.unName fieldName)) (Core.caseStatementCases cs) - in (Logic.ifElse (Lists.null matching) (Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError "not enough cases")), - Context.inContextContext = cx})) (Right (Lists.head matching))))) - --- | Extract case statement from a term -cases :: Context.Context -> Core.Name -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) Core.CaseStatement -cases cx name graph term0 = - Eithers.bind (Lexical.stripAndDereferenceTerm cx graph term0) (\term -> case term of - Core.TermFunction v0 -> case v0 of - Core.FunctionElimination v1 -> case v1 of - Core.EliminationUnion v2 -> Logic.ifElse (Equality.equal (Core.unName (Core.caseStatementTypeName v2)) (Core.unName name)) (Right v2) (Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " (Strings.cat2 "case statement for type " (Core.unName name))) " but found ") (Core_.term term)))), - Context.inContextContext = cx})) - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "case statement") " but found ") (Core_.term term)))), - Context.inContextContext = cx}) - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "case statement") " but found ") (Core_.term term)))), - Context.inContextContext = cx}) - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "case statement") " but found ") (Core_.term term)))), - Context.inContextContext = cx})) - --- | Extract an either value from a term, applying functions to the left and right values -eitherTerm :: Context.Context -> (Core.Term -> Either (Context.InContext Errors.Error) t0) -> (Core.Term -> Either (Context.InContext Errors.Error) t1) -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) (Either t0 t1) -eitherTerm cx leftFun rightFun graph term0 = - Eithers.bind (Lexical.stripAndDereferenceTerm cx graph term0) (\term -> case term of - Core.TermEither v0 -> Eithers.either (\l -> Eithers.map (\x -> Left x) (leftFun l)) (\r -> Eithers.map (\x -> Right x) (rightFun r)) v0 - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "either value") " but found ") (Core_.term term)))), - Context.inContextContext = cx})) - --- | Extract the left and right types from an either type -eitherType :: Context.Context -> Core.Type -> Either (Context.InContext Errors.Error) Core.EitherType -eitherType cx typ = - - let stripped = Rewriting.deannotateType typ - in case stripped of - Core.TypeEither v0 -> Right v0 - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "either type") " but found ") (Core_.type_ typ)))), - Context.inContextContext = cx}) - --- | Extract a field value from a list of fields -field :: Context.Context -> Core.Name -> (Core.Term -> Either (Context.InContext Errors.Error) t0) -> Graph.Graph -> [Core.Field] -> Either (Context.InContext Errors.Error) t0 -field cx fname mapping graph fields = - - let matchingFields = Lists.filter (\f -> Equality.equal (Core.unName (Core.fieldName f)) (Core.unName fname)) fields - in (Logic.ifElse (Lists.null matchingFields) (Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " (Strings.cat2 "field " (Core.unName fname))) " but found ") "no matching field"))), - Context.inContextContext = cx})) (Logic.ifElse (Equality.equal (Lists.length matchingFields) 1) (Eithers.bind (Lexical.stripAndDereferenceTerm cx graph (Core.fieldTerm (Lists.head matchingFields))) (\stripped -> mapping stripped)) (Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "single field") " but found ") (Strings.cat2 "multiple fields named " (Core.unName fname))))), - Context.inContextContext = cx})))) - --- | Extract a 32-bit floating-point value from a term -float32 :: Context.Context -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) Float -float32 cx graph t = Eithers.bind (literal cx graph t) (\l -> Eithers.bind (floatLiteral cx l) (\f -> float32Value cx f)) - --- | Extract a float32 value from a FloatValue -float32Value :: Context.Context -> Core.FloatValue -> Either (Context.InContext Errors.Error) Float -float32Value cx v = - case v of - Core.FloatValueFloat32 v0 -> Right v0 - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "float32") " but found ") (Core_.float v)))), - Context.inContextContext = cx}) - --- | Extract a 64-bit floating-point value from a term -float64 :: Context.Context -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) Double -float64 cx graph t = Eithers.bind (literal cx graph t) (\l -> Eithers.bind (floatLiteral cx l) (\f -> float64Value cx f)) - --- | Extract a float64 value from a FloatValue -float64Value :: Context.Context -> Core.FloatValue -> Either (Context.InContext Errors.Error) Double -float64Value cx v = - case v of - Core.FloatValueFloat64 v0 -> Right v0 - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "float64") " but found ") (Core_.float v)))), - Context.inContextContext = cx}) - --- | Extract a floating-point literal from a Literal value -floatLiteral :: Context.Context -> Core.Literal -> Either (Context.InContext Errors.Error) Core.FloatValue -floatLiteral cx lit = - case lit of - Core.LiteralFloat v0 -> Right v0 - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "floating-point value") " but found ") (Core_.literal lit)))), - Context.inContextContext = cx}) - --- | Extract a float value from a term -floatValue :: Context.Context -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) Core.FloatValue -floatValue cx graph t = Eithers.bind (literal cx graph t) (\l -> floatLiteral cx l) - --- | Extract a function type from a type -functionType :: Context.Context -> Core.Type -> Either (Context.InContext Errors.Error) Core.FunctionType -functionType cx typ = - - let stripped = Rewriting.deannotateType typ - in case stripped of - Core.TypeFunction v0 -> Right v0 - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "function type") " but found ") (Core_.type_ typ)))), - Context.inContextContext = cx}) - --- | Extract a field from a union term -injection :: Context.Context -> Core.Name -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) Core.Field -injection cx expected graph term0 = - Eithers.bind (Lexical.stripAndDereferenceTerm cx graph term0) (\term -> case term of - Core.TermUnion v0 -> Logic.ifElse (Equality.equal (Core.unName (Core.injectionTypeName v0)) (Core.unName expected)) (Right (Core.injectionField v0)) (Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " (Strings.cat2 "injection of type " (Core.unName expected))) " but found ") (Core.unName (Core.injectionTypeName v0))))), - Context.inContextContext = cx})) - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "injection") " but found ") (Core_.term term)))), - Context.inContextContext = cx})) - --- | Extract a 16-bit signed integer value from a term -int16 :: Context.Context -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) I.Int16 -int16 cx graph t = Eithers.bind (literal cx graph t) (\l -> Eithers.bind (integerLiteral cx l) (\i -> int16Value cx i)) - --- | Extract an int16 value from an IntegerValue -int16Value :: Context.Context -> Core.IntegerValue -> Either (Context.InContext Errors.Error) I.Int16 -int16Value cx v = - case v of - Core.IntegerValueInt16 v0 -> Right v0 - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "int16") " but found ") (Core_.integer v)))), - Context.inContextContext = cx}) - --- | Extract a 32-bit signed integer value from a term -int32 :: Context.Context -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) Int -int32 cx graph t = Eithers.bind (literal cx graph t) (\l -> Eithers.bind (integerLiteral cx l) (\i -> int32Value cx i)) - --- | Extract an int32 value from an IntegerValue -int32Value :: Context.Context -> Core.IntegerValue -> Either (Context.InContext Errors.Error) Int -int32Value cx v = - case v of - Core.IntegerValueInt32 v0 -> Right v0 - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "int32") " but found ") (Core_.integer v)))), - Context.inContextContext = cx}) - --- | Extract a 64-bit signed integer value from a term -int64 :: Context.Context -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) I.Int64 -int64 cx graph t = Eithers.bind (literal cx graph t) (\l -> Eithers.bind (integerLiteral cx l) (\i -> int64Value cx i)) - --- | Extract an int64 value from an IntegerValue -int64Value :: Context.Context -> Core.IntegerValue -> Either (Context.InContext Errors.Error) I.Int64 -int64Value cx v = - case v of - Core.IntegerValueInt64 v0 -> Right v0 - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "int64") " but found ") (Core_.integer v)))), - Context.inContextContext = cx}) - --- | Extract an 8-bit signed integer value from a term -int8 :: Context.Context -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) I.Int8 -int8 cx graph t = Eithers.bind (literal cx graph t) (\l -> Eithers.bind (integerLiteral cx l) (\i -> int8Value cx i)) - --- | Extract an int8 value from an IntegerValue -int8Value :: Context.Context -> Core.IntegerValue -> Either (Context.InContext Errors.Error) I.Int8 -int8Value cx v = - case v of - Core.IntegerValueInt8 v0 -> Right v0 - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "int8") " but found ") (Core_.integer v)))), - Context.inContextContext = cx}) - --- | Extract an integer literal from a Literal value -integerLiteral :: Context.Context -> Core.Literal -> Either (Context.InContext Errors.Error) Core.IntegerValue -integerLiteral cx lit = - case lit of - Core.LiteralInteger v0 -> Right v0 - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "integer value") " but found ") (Core_.literal lit)))), - Context.inContextContext = cx}) - --- | Extract an integer value from a term -integerValue :: Context.Context -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) Core.IntegerValue -integerValue cx graph t = Eithers.bind (literal cx graph t) (\l -> integerLiteral cx l) - --- | Extract a lambda from a term -lambda :: Context.Context -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) Core.Lambda -lambda cx graph term0 = - Eithers.bind (Lexical.stripAndDereferenceTerm cx graph term0) (\term -> case term of - Core.TermFunction v0 -> case v0 of - Core.FunctionLambda v1 -> Right v1 - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "lambda") " but found ") (Core_.term term)))), - Context.inContextContext = cx}) - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "lambda") " but found ") (Core_.term term)))), - Context.inContextContext = cx})) - --- | Extract the body of a lambda term -lambdaBody :: Context.Context -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -lambdaBody cx graph term = Eithers.map Core.lambdaBody (lambda cx graph term) - --- | Extract a let expression from a term -let_ :: Context.Context -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) Core.Let -let_ cx graph term0 = - Eithers.bind (Lexical.stripAndDereferenceTerm cx graph term0) (\term -> case term of - Core.TermLet v0 -> Right v0 - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "let term") " but found ") (Core_.term term)))), - Context.inContextContext = cx})) - --- | Extract a binding with the given name from a let term -letBinding :: Context.Context -> String -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -letBinding cx n graph term = - - let name = Core.Name n - in (Eithers.bind (let_ cx graph term) (\letExpr -> - let matchingBindings = - Lists.filter (\b -> Equality.equal (Core.unName (Core.bindingName b)) (Core.unName name)) (Core.letBindings letExpr) - in (Logic.ifElse (Lists.null matchingBindings) (Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 "no such binding: " n))), - Context.inContextContext = cx})) (Logic.ifElse (Equality.equal (Lists.length matchingBindings) 1) (Right (Core.bindingTerm (Lists.head matchingBindings))) (Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 "multiple bindings named " n))), - Context.inContextContext = cx})))))) - --- | Extract a list of terms from a term -list :: Context.Context -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) [Core.Term] -list cx graph term = - Eithers.bind (Lexical.stripAndDereferenceTerm cx graph term) (\stripped -> case stripped of - Core.TermList v0 -> Right v0 - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "list") " but found ") (Core_.term stripped)))), - Context.inContextContext = cx})) - --- | Extract the first element of a list term -listHead :: Context.Context -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -listHead cx graph term = - Eithers.bind (list cx graph term) (\l -> Logic.ifElse (Lists.null l) (Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError "empty list")), - Context.inContextContext = cx})) (Right (Lists.head l))) - --- | Extract a list of values from a term, mapping a function over each element -listOf :: Context.Context -> (Core.Term -> Either (Context.InContext Errors.Error) t0) -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) [t0] -listOf cx f graph term = Eithers.bind (list cx graph term) (\els -> Eithers.mapList f els) - --- | Extract the element type from a list type -listType :: Context.Context -> Core.Type -> Either (Context.InContext Errors.Error) Core.Type -listType cx typ = - - let stripped = Rewriting.deannotateType typ - in case stripped of - Core.TypeList v0 -> Right v0 - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "list type") " but found ") (Core_.type_ typ)))), - Context.inContextContext = cx}) - --- | Extract a literal value from a term -literal :: Context.Context -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) Core.Literal -literal cx graph term0 = - Eithers.bind (Lexical.stripAndDereferenceTerm cx graph term0) (\term -> case term of - Core.TermLiteral v0 -> Right v0 - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "literal") " but found ") (Core_.term term)))), - Context.inContextContext = cx})) - --- | Extract a map of key-value pairs from a term, mapping functions over each key and value -map :: Ord t0 => (Context.Context -> (Core.Term -> Either (Context.InContext Errors.Error) t0) -> (Core.Term -> Either (Context.InContext Errors.Error) t1) -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) (M.Map t0 t1)) -map cx fk fv graph term0 = - - let pair = - \kvPair -> - let kterm = Pairs.first kvPair - vterm = Pairs.second kvPair - in (Eithers.bind (fk kterm) (\kval -> Eithers.bind (fv vterm) (\vval -> Right (kval, vval)))) - in (Eithers.bind (Lexical.stripAndDereferenceTerm cx graph term0) (\term -> case term of - Core.TermMap v0 -> Eithers.map Maps.fromList (Eithers.mapList pair (Maps.toList v0)) - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "map") " but found ") (Core_.term term)))), - Context.inContextContext = cx}))) - --- | Extract the key and value types from a map type -mapType :: Context.Context -> Core.Type -> Either (Context.InContext Errors.Error) Core.MapType -mapType cx typ = - - let stripped = Rewriting.deannotateType typ - in case stripped of - Core.TypeMap v0 -> Right v0 - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "map type") " but found ") (Core_.type_ typ)))), - Context.inContextContext = cx}) - --- | Extract an optional value from a term, applying a function to the value if present -maybeTerm :: Context.Context -> (Core.Term -> Either (Context.InContext Errors.Error) t0) -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) (Maybe t0) -maybeTerm cx f graph term0 = - Eithers.bind (Lexical.stripAndDereferenceTerm cx graph term0) (\term -> case term of - Core.TermMaybe v0 -> Maybes.maybe (Right Nothing) (\t -> Eithers.map Maybes.pure (f t)) v0 - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "maybe value") " but found ") (Core_.term term)))), - Context.inContextContext = cx})) - --- | Extract the base type from an optional type -maybeType :: Context.Context -> Core.Type -> Either (Context.InContext Errors.Error) Core.Type -maybeType cx typ = - - let stripped = Rewriting.deannotateType typ - in case stripped of - Core.TypeMaybe v0 -> Right v0 - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "maybe type") " but found ") (Core_.type_ typ)))), - Context.inContextContext = cx}) - --- | Ensure a function has the expected number of arguments -nArgs :: Context.Context -> Core.Name -> Int -> [t0] -> Either (Context.InContext Errors.Error) () -nArgs cx name n args = - Logic.ifElse (Equality.equal (Lists.length args) n) (Right ()) (Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " (Strings.cat [ - Literals.showInt32 n, - " arguments to primitive ", - (Literals.showString (Core.unName name))])) " but found ") (Literals.showInt32 (Lists.length args))))), - Context.inContextContext = cx})) - --- | Extract a pair of values from a term, applying functions to each component -pair :: Context.Context -> (Core.Term -> Either (Context.InContext Errors.Error) t0) -> (Core.Term -> Either (Context.InContext Errors.Error) t1) -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) (t0, t1) -pair cx kf vf graph term0 = - Eithers.bind (Lexical.stripAndDereferenceTerm cx graph term0) (\term -> case term of - Core.TermPair v0 -> Eithers.bind (kf (Pairs.first v0)) (\kVal -> Eithers.bind (vf (Pairs.second v0)) (\vVal -> Right (kVal, vVal))) - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "pair") " but found ") (Core_.term term)))), - Context.inContextContext = cx})) - --- | Extract a record's fields from a term -record :: Context.Context -> Core.Name -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) [Core.Field] -record cx expected graph term0 = - Eithers.bind (termRecord cx graph term0) (\record -> Logic.ifElse (Equality.equal (Core.recordTypeName record) expected) (Right (Core.recordFields record)) (Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " (Strings.cat2 "record of type " (Core.unName expected))) " but found ") (Core.unName (Core.recordTypeName record))))), - Context.inContextContext = cx}))) - --- | Extract the field types from a record type -recordType :: Context.Context -> t0 -> Core.Type -> Either (Context.InContext Errors.Error) [Core.FieldType] -recordType cx ename typ = - - let stripped = Rewriting.deannotateType typ - in case stripped of - Core.TypeRecord v0 -> Right v0 - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "record type") " but found ") (Core_.type_ typ)))), - Context.inContextContext = cx}) - --- | Extract a set of terms from a term -set :: Context.Context -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) (S.Set Core.Term) -set cx graph term = - Eithers.bind (Lexical.stripAndDereferenceTerm cx graph term) (\stripped -> case stripped of - Core.TermSet v0 -> Right v0 - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "set") " but found ") (Core_.term stripped)))), - Context.inContextContext = cx})) - --- | Extract a set of values from a term, mapping a function over each element -setOf :: Ord t0 => (Context.Context -> (Core.Term -> Either (Context.InContext Errors.Error) t0) -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) (S.Set t0)) -setOf cx f graph term = Eithers.bind (set cx graph term) (\els -> Eithers.mapSet f els) - --- | Extract the element type from a set type -setType :: Context.Context -> Core.Type -> Either (Context.InContext Errors.Error) Core.Type -setType cx typ = - - let stripped = Rewriting.deannotateType typ - in case stripped of - Core.TypeSet v0 -> Right v0 - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "set type") " but found ") (Core_.type_ typ)))), - Context.inContextContext = cx}) - --- | Extract a string value from a term -string :: Context.Context -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) String -string cx graph t = Eithers.bind (literal cx graph t) (\l -> stringLiteral cx l) - --- | Extract a string literal from a Literal value -stringLiteral :: Context.Context -> Core.Literal -> Either (Context.InContext Errors.Error) String -stringLiteral cx v = - case v of - Core.LiteralString v0 -> Right v0 - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "string") " but found ") (Core_.literal v)))), - Context.inContextContext = cx}) - --- | Extract a record from a term -termRecord :: Context.Context -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) Core.Record -termRecord cx graph term0 = - Eithers.bind (Lexical.stripAndDereferenceTerm cx graph term0) (\term -> case term of - Core.TermRecord v0 -> Right v0 - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "record") " but found ") (Core_.term term)))), - Context.inContextContext = cx})) - --- | Extract a 16-bit unsigned integer value from a term -uint16 :: Context.Context -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) Int -uint16 cx graph t = Eithers.bind (literal cx graph t) (\l -> Eithers.bind (integerLiteral cx l) (\i -> uint16Value cx i)) - --- | Extract a uint16 value from an IntegerValue -uint16Value :: Context.Context -> Core.IntegerValue -> Either (Context.InContext Errors.Error) Int -uint16Value cx v = - case v of - Core.IntegerValueUint16 v0 -> Right v0 - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "uint16") " but found ") (Core_.integer v)))), - Context.inContextContext = cx}) - --- | Extract a 32-bit unsigned integer value from a term -uint32 :: Context.Context -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) I.Int64 -uint32 cx graph t = Eithers.bind (literal cx graph t) (\l -> Eithers.bind (integerLiteral cx l) (\i -> uint32Value cx i)) - --- | Extract a uint32 value from an IntegerValue -uint32Value :: Context.Context -> Core.IntegerValue -> Either (Context.InContext Errors.Error) I.Int64 -uint32Value cx v = - case v of - Core.IntegerValueUint32 v0 -> Right v0 - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "uint32") " but found ") (Core_.integer v)))), - Context.inContextContext = cx}) - --- | Extract a 64-bit unsigned integer value from a term -uint64 :: Context.Context -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) Integer -uint64 cx graph t = Eithers.bind (literal cx graph t) (\l -> Eithers.bind (integerLiteral cx l) (\i -> uint64Value cx i)) - --- | Extract a uint64 value from an IntegerValue -uint64Value :: Context.Context -> Core.IntegerValue -> Either (Context.InContext Errors.Error) Integer -uint64Value cx v = - case v of - Core.IntegerValueUint64 v0 -> Right v0 - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "uint64") " but found ") (Core_.integer v)))), - Context.inContextContext = cx}) - --- | Extract an 8-bit unsigned integer value from a term -uint8 :: Context.Context -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) I.Int16 -uint8 cx graph t = Eithers.bind (literal cx graph t) (\l -> Eithers.bind (integerLiteral cx l) (\i -> uint8Value cx i)) - --- | Extract a uint8 value from an IntegerValue -uint8Value :: Context.Context -> Core.IntegerValue -> Either (Context.InContext Errors.Error) I.Int16 -uint8Value cx v = - case v of - Core.IntegerValueUint8 v0 -> Right v0 - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "uint8") " but found ") (Core_.integer v)))), - Context.inContextContext = cx}) - --- | Extract the field types from a union type -unionType :: Context.Context -> t0 -> Core.Type -> Either (Context.InContext Errors.Error) [Core.FieldType] -unionType cx ename typ = - - let stripped = Rewriting.deannotateType typ - in case stripped of - Core.TypeUnion v0 -> Right v0 - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "union type") " but found ") (Core_.type_ typ)))), - Context.inContextContext = cx}) - --- | Extract a unit value from a term -unit :: Context.Context -> Core.Term -> Either (Context.InContext Errors.Error) () -unit cx term = - case term of - Core.TermUnit -> Right () - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "unit") " but found ") (Core_.term term)))), - Context.inContextContext = cx}) - --- | Extract a unit variant (a variant with an empty record value) from a union term -unitVariant :: Context.Context -> Core.Name -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) Core.Name -unitVariant cx tname graph term = - Eithers.bind (injection cx tname graph term) (\field -> Eithers.bind (unit cx (Core.fieldTerm field)) (\ignored -> Right (Core.fieldName field))) - --- | Extract the wrapped value from a wrapped term -wrap :: Context.Context -> Core.Name -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -wrap cx expected graph term0 = - Eithers.bind (Lexical.stripAndDereferenceTerm cx graph term0) (\term -> case term of - Core.TermWrap v0 -> Logic.ifElse (Equality.equal (Core.unName (Core.wrappedTermTypeName v0)) (Core.unName expected)) (Right (Core.wrappedTermBody v0)) (Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " (Strings.cat2 "wrapper of type " (Core.unName expected))) " but found ") (Core.unName (Core.wrappedTermTypeName v0))))), - Context.inContextContext = cx})) - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " (Strings.cat2 (Strings.cat2 "wrap(" (Core.unName expected)) ")")) " but found ") (Core_.term term)))), - Context.inContextContext = cx})) - --- | Extract the wrapped type from a wrapper type -wrappedType :: Context.Context -> t0 -> Core.Type -> Either (Context.InContext Errors.Error) Core.Type -wrappedType cx ename typ = - - let stripped = Rewriting.deannotateType typ - in case stripped of - Core.TypeWrap v0 -> Right v0 - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected " "wrapped type") " but found ") (Core_.type_ typ)))), - Context.inContextContext = cx}) diff --git a/src/gen-main/haskell/Hydra/Extract/Helpers.hs b/src/gen-main/haskell/Hydra/Extract/Helpers.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Extract/Helpers.hs +++ /dev/null @@ -1,91 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Helper functions for decoding terms to domain types - -module Hydra.Extract.Helpers where - -import qualified Hydra.Core as Core -import qualified Hydra.Errors as Errors -import qualified Hydra.Graph as Graph -import qualified Hydra.Lexical as Lexical -import qualified Hydra.Lib.Eithers as Eithers -import qualified Hydra.Lib.Lists as Lists -import qualified Hydra.Lib.Maps as Maps -import qualified Hydra.Lib.Maybes as Maybes -import qualified Hydra.Lib.Pairs as Pairs -import qualified Hydra.Lib.Sets as Sets -import qualified Hydra.Lib.Strings as Strings -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | Decode an Either value using the provided left and right decoders -decodeEither :: (Graph.Graph -> Core.Term -> Either Errors.DecodingError t0) -> (Graph.Graph -> Core.Term -> Either Errors.DecodingError t1) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (Either t0 t1) -decodeEither leftDecoder rightDecoder g term = - Eithers.bind (Eithers.bimap (\x -> Errors.DecodingError x) (\x -> x) (Lexical.stripAndDereferenceTermEither g term)) (\stripped -> case stripped of - Core.TermEither v0 -> Eithers.either (\lv -> Eithers.map (\x -> Left x) (leftDecoder g lv)) (\rv -> Eithers.map (\x -> Right x) (rightDecoder g rv)) v0 - _ -> Left (Errors.DecodingError "expected either value")) - --- | Decode a list of elements using the provided element decoder -decodeList :: (Graph.Graph -> Core.Term -> Either Errors.DecodingError t0) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError [t0] -decodeList elemDecoder g term = - Eithers.bind (Eithers.bimap (\x -> Errors.DecodingError x) (\x -> x) (Lexical.stripAndDereferenceTermEither g term)) (\stripped -> case stripped of - Core.TermList v0 -> Eithers.mapList (elemDecoder g) v0 - _ -> Left (Errors.DecodingError "expected list")) - --- | Decode a Map using the provided key and value decoders -decodeMap :: Ord t0 => ((Graph.Graph -> Core.Term -> Either Errors.DecodingError t0) -> (Graph.Graph -> Core.Term -> Either Errors.DecodingError t1) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (M.Map t0 t1)) -decodeMap keyDecoder valDecoder g term = - Eithers.bind (Eithers.bimap (\x -> Errors.DecodingError x) (\x -> x) (Lexical.stripAndDereferenceTermEither g term)) (\stripped -> case stripped of - Core.TermMap v0 -> Eithers.map Maps.fromList (Eithers.mapList (\kv -> Eithers.bind (keyDecoder g (Pairs.first kv)) (\k -> Eithers.map (\v -> (k, v)) (valDecoder g (Pairs.second kv)))) (Maps.toList v0)) - _ -> Left (Errors.DecodingError "expected map")) - --- | Decode a Maybe value using the provided element decoder -decodeMaybe :: (Graph.Graph -> Core.Term -> Either Errors.DecodingError t0) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (Maybe t0) -decodeMaybe elemDecoder g term = - Eithers.bind (Eithers.bimap (\x -> Errors.DecodingError x) (\x -> x) (Lexical.stripAndDereferenceTermEither g term)) (\stripped -> case stripped of - Core.TermMaybe v0 -> Eithers.mapMaybe (elemDecoder g) v0 - _ -> Left (Errors.DecodingError "expected optional value")) - --- | Decode a Pair using the provided first and second decoders -decodePair :: (Graph.Graph -> Core.Term -> Either Errors.DecodingError t0) -> (Graph.Graph -> Core.Term -> Either Errors.DecodingError t1) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (t0, t1) -decodePair firstDecoder secondDecoder g term = - Eithers.bind (Eithers.bimap (\x -> Errors.DecodingError x) (\x -> x) (Lexical.stripAndDereferenceTermEither g term)) (\stripped -> case stripped of - Core.TermPair v0 -> Eithers.bind (firstDecoder g (Pairs.first v0)) (\f -> Eithers.map (\s -> (f, s)) (secondDecoder g (Pairs.second v0))) - _ -> Left (Errors.DecodingError "expected pair")) - --- | Decode a Set using the provided element decoder -decodeSet :: Ord t0 => ((Graph.Graph -> Core.Term -> Either Errors.DecodingError t0) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (S.Set t0)) -decodeSet elemDecoder g term = - Eithers.bind (Eithers.bimap (\x -> Errors.DecodingError x) (\x -> x) (Lexical.stripAndDereferenceTermEither g term)) (\stripped -> case stripped of - Core.TermSet v0 -> Eithers.map Sets.fromList (Eithers.mapList (elemDecoder g) (Sets.toList v0)) - _ -> Left (Errors.DecodingError "expected set")) - --- | Decode a unit value -decodeUnit :: Graph.Graph -> Core.Term -> Either Errors.DecodingError () -decodeUnit g term = - Eithers.bind (Eithers.bimap (\x -> Errors.DecodingError x) (\x -> x) (Lexical.stripAndDereferenceTermEither g term)) (\stripped -> case stripped of - Core.TermUnit -> Right () - _ -> Left (Errors.DecodingError "expected a unit value")) - --- | Decode a wrapped value using the provided body decoder -decodeWrapped :: (Graph.Graph -> Core.Term -> Either Errors.DecodingError t0) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError t0 -decodeWrapped bodyDecoder g term = - Eithers.bind (Eithers.bimap (\x -> Errors.DecodingError x) (\x -> x) (Lexical.stripAndDereferenceTermEither g term)) (\stripped -> case stripped of - Core.TermWrap v0 -> bodyDecoder g (Core.wrappedTermBody v0) - _ -> Left (Errors.DecodingError "expected wrapped value")) - --- | Require a field from a record's field map and decode it -requireField :: String -> (t0 -> t1 -> Either Errors.DecodingError t2) -> M.Map Core.Name t1 -> t0 -> Either Errors.DecodingError t2 -requireField fieldName decoder fieldMap g = - Maybes.maybe (Left (Errors.DecodingError (Strings.cat [ - "missing field ", - fieldName, - " in record"]))) (\fieldTerm -> decoder g fieldTerm) (Maps.lookup (Core.Name fieldName) fieldMap) - --- | Convert a Record's fields to a Map from Name to Term -toFieldMap :: Core.Record -> M.Map Core.Name Core.Term -toFieldMap record = Maps.fromList (Lists.map (\f -> (Core.fieldName f, (Core.fieldTerm f))) (Core.recordFields record)) diff --git a/src/gen-main/haskell/Hydra/Extract/Json.hs b/src/gen-main/haskell/Hydra/Extract/Json.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Extract/Json.hs +++ /dev/null @@ -1,81 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Utilities for extracting values from JSON objects - -module Hydra.Extract.Json where - -import qualified Hydra.Json.Model as Model -import qualified Hydra.Lib.Eithers as Eithers -import qualified Hydra.Lib.Maps as Maps -import qualified Hydra.Lib.Maybes as Maybes -import qualified Hydra.Lib.Strings as Strings -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | Extract an array from a JSON value, failing if the value is not an array -expectArray :: Model.Value -> Either String [Model.Value] -expectArray value = - case value of - Model.ValueArray v0 -> Right v0 - _ -> Left (Strings.cat2 (Strings.cat2 "expected " "JSON array") (Strings.cat2 " but found " (showValue value))) - --- | Extract a number from a JSON value, failing if the value is not a number -expectNumber :: Model.Value -> Either String Double -expectNumber value = - case value of - Model.ValueNumber v0 -> Right v0 - _ -> Left (Strings.cat2 (Strings.cat2 "expected " "JSON number") (Strings.cat2 " but found " (showValue value))) - --- | Extract an object from a JSON value, failing if the value is not an object -expectObject :: Model.Value -> Either String (M.Map String Model.Value) -expectObject value = - case value of - Model.ValueObject v0 -> Right v0 - _ -> Left (Strings.cat2 (Strings.cat2 "expected " "JSON object") (Strings.cat2 " but found " (showValue value))) - --- | Extract a string from a JSON value, failing if the value is not a string -expectString :: Model.Value -> Either String String -expectString value = - case value of - Model.ValueString v0 -> Right v0 - _ -> Left (Strings.cat2 (Strings.cat2 "expected " "JSON string") (Strings.cat2 " but found " (showValue value))) - --- | Look up an optional field in a JSON object -opt :: Ord t0 => (t0 -> M.Map t0 t1 -> Maybe t1) -opt fname m = Maps.lookup fname m - --- | Look up an optional array field in a JSON object -optArray :: Ord t0 => (t0 -> M.Map t0 Model.Value -> Either String (Maybe [Model.Value])) -optArray fname m = Maybes.maybe (Right Nothing) (\a -> Eithers.map (\x -> Just x) (expectArray a)) (opt fname m) - --- | Look up an optional string field in a JSON object -optString :: Ord t0 => (t0 -> M.Map t0 Model.Value -> Either String (Maybe String)) -optString fname m = Maybes.maybe (Right Nothing) (\s -> Eithers.map (\x -> Just x) (expectString s)) (opt fname m) - --- | Look up a required field in a JSON object, failing if not found -require :: Ord t0 => (t0 -> M.Map t0 t1 -> Either String t1) -require fname m = - Maybes.maybe (Left (Strings.cat [ - "required attribute ", - (showValue fname), - " not found"])) (\value -> Right value) (Maps.lookup fname m) - --- | Look up a required array field in a JSON object -requireArray :: Ord t0 => (t0 -> M.Map t0 Model.Value -> Either String [Model.Value]) -requireArray fname m = Eithers.bind (require fname m) expectArray - --- | Look up a required number field in a JSON object -requireNumber :: Ord t0 => (t0 -> M.Map t0 Model.Value -> Either String Double) -requireNumber fname m = Eithers.bind (require fname m) expectNumber - --- | Look up a required string field in a JSON object -requireString :: Ord t0 => (t0 -> M.Map t0 Model.Value -> Either String String) -requireString fname m = Eithers.bind (require fname m) expectString - --- | Show a JSON value as a string (placeholder implementation) -showValue :: t0 -> String -showValue value = "TODO: implement showValue" diff --git a/src/gen-main/haskell/Hydra/Extract/Util.hs b/src/gen-main/haskell/Hydra/Extract/Util.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Extract/Util.hs +++ /dev/null @@ -1,29 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Extraction and validation for hydra.util types - -module Hydra.Extract.Util where - -import qualified Hydra.Context as Context -import qualified Hydra.Core as Core -import qualified Hydra.Errors as Errors -import qualified Hydra.Extract.Core as Core_ -import qualified Hydra.Graph as Graph -import qualified Hydra.Lib.Eithers as Eithers -import qualified Hydra.Lib.Equality as Equality -import qualified Hydra.Lib.Logic as Logic -import qualified Hydra.Lib.Strings as Strings -import qualified Hydra.Util as Util -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | Extract a comparison from a term -comparison :: Context.Context -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) Util.Comparison -comparison cx graph term = - Eithers.bind (Core_.unitVariant cx (Core.Name "hydra.util.Comparison") graph term) (\fname -> Logic.ifElse (Equality.equal (Core.unName fname) "equalTo") (Right Util.ComparisonEqualTo) (Logic.ifElse (Equality.equal (Core.unName fname) "lessThan") (Right Util.ComparisonLessThan) (Logic.ifElse (Equality.equal (Core.unName fname) "greaterThan") (Right Util.ComparisonGreaterThan) (Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 "expected comparison but found " (Core.unName fname)))), - Context.inContextContext = cx}))))) diff --git a/src/gen-main/haskell/Hydra/Formatting.hs b/src/gen-main/haskell/Hydra/Formatting.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Formatting.hs +++ /dev/null @@ -1,186 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | String formatting types and functions. - -module Hydra.Formatting where - -import qualified Hydra.Lib.Chars as Chars -import qualified Hydra.Lib.Equality as Equality -import qualified Hydra.Lib.Lists as Lists -import qualified Hydra.Lib.Logic as Logic -import qualified Hydra.Lib.Maps as Maps -import qualified Hydra.Lib.Maybes as Maybes -import qualified Hydra.Lib.Pairs as Pairs -import qualified Hydra.Lib.Sets as Sets -import qualified Hydra.Lib.Strings as Strings -import qualified Hydra.Util as Util -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | Capitalize the first letter of a string -capitalize :: String -> String -capitalize = mapFirstLetter Strings.toUpper - --- | Convert a string from one case convention to another -convertCase :: Util.CaseConvention -> Util.CaseConvention -> String -> String -convertCase from to original = - - let parts = - - let byCaps = - - let splitOnUppercase = - \acc -> \c -> Lists.concat2 (Logic.ifElse (Chars.isUpper c) [ - []] []) (Lists.cons (Lists.cons c (Lists.head acc)) (Lists.tail acc)) - in (Lists.map Strings.fromList (Lists.foldl splitOnUppercase [ - []] (Lists.reverse (Strings.toList (decapitalize original))))) - byUnderscores = Strings.splitOn "_" original - in case from of - Util.CaseConventionCamel -> byCaps - Util.CaseConventionPascal -> byCaps - Util.CaseConventionLowerSnake -> byUnderscores - Util.CaseConventionUpperSnake -> byUnderscores - in case to of - Util.CaseConventionCamel -> decapitalize (Strings.cat (Lists.map (\arg_ -> capitalize (Strings.toLower arg_)) parts)) - Util.CaseConventionPascal -> Strings.cat (Lists.map (\arg_ -> capitalize (Strings.toLower arg_)) parts) - Util.CaseConventionLowerSnake -> Strings.intercalate "_" (Lists.map Strings.toLower parts) - Util.CaseConventionUpperSnake -> Strings.intercalate "_" (Lists.map Strings.toUpper parts) - --- | Convert a string from camel case (possibly with underscores) to lower snake case. Splits on underscores first, then converts each part from camel case. -convertCaseCamelOrUnderscoreToLowerSnake :: String -> String -convertCaseCamelOrUnderscoreToLowerSnake s = - - let parts = Strings.splitOn "_" s - snakeParts = Lists.map (\p -> convertCaseCamelToLowerSnake p) parts - in (Strings.intercalate "_" snakeParts) - --- | Convert a string from camel case to lower snake case -convertCaseCamelToLowerSnake :: String -> String -convertCaseCamelToLowerSnake = convertCase Util.CaseConventionCamel Util.CaseConventionLowerSnake - --- | Convert a string from camel case to upper snake case -convertCaseCamelToUpperSnake :: String -> String -convertCaseCamelToUpperSnake = convertCase Util.CaseConventionCamel Util.CaseConventionUpperSnake - --- | Convert a string from pascal case to upper snake case -convertCasePascalToUpperSnake :: String -> String -convertCasePascalToUpperSnake = convertCase Util.CaseConventionPascal Util.CaseConventionUpperSnake - --- | Decapitalize the first letter of a string -decapitalize :: String -> String -decapitalize = mapFirstLetter Strings.toLower - --- | Escape reserved words by appending an underscore -escapeWithUnderscore :: S.Set String -> String -> String -escapeWithUnderscore reserved s = Logic.ifElse (Sets.member s reserved) (Strings.cat2 s "_") s - --- | Indent each line of a string with four spaces -indentLines :: String -> String -indentLines s = - - let indent = \l -> Strings.cat2 " " l - in (Strings.unlines (Lists.map indent (Strings.lines s))) - --- | Format a string as a Java-style block comment -javaStyleComment :: String -> String -javaStyleComment s = Strings.cat2 (Strings.cat2 (Strings.cat2 "/**\n" " * ") s) "\n */" - --- | A helper which maps the first letter of a string to another string -mapFirstLetter :: (String -> String) -> String -> String -mapFirstLetter mapping s = - Logic.ifElse (Strings.null s) s ( - let list = Strings.toList s - firstLetter = mapping (Strings.fromList (Lists.pure (Lists.head list))) - in (Strings.cat2 firstLetter (Strings.fromList (Lists.tail list)))) - --- | Replace sequences of non-alphanumeric characters with single underscores -nonAlnumToUnderscores :: String -> String -nonAlnumToUnderscores input = - - let isAlnum = - \c -> Logic.or (Logic.and (Equality.gte c 65) (Equality.lte c 90)) (Logic.or (Logic.and (Equality.gte c 97) (Equality.lte c 122)) (Logic.and (Equality.gte c 48) (Equality.lte c 57))) - replace = - \p -> \c -> - let s = Pairs.first p - b = Pairs.second p - in (Logic.ifElse (isAlnum c) (Lists.cons c s, False) (Logic.ifElse b (s, True) (Lists.cons 95 s, True))) - result = Lists.foldl replace ([], False) (Strings.toList input) - in (Strings.fromList (Lists.reverse (Pairs.first result))) - --- | Sanitize a string by replacing non-alphanumeric characters and escaping reserved words -sanitizeWithUnderscores :: S.Set String -> String -> String -sanitizeWithUnderscores reserved s = escapeWithUnderscore reserved (nonAlnumToUnderscores s) - --- | Format a list of elements as a bracketed, comma-separated string -showList :: (t0 -> String) -> [t0] -> String -showList f els = - Strings.cat [ - "[", - (Strings.intercalate ", " (Lists.map f els)), - "]"] - --- | Remove leading and trailing whitespace from a string -stripLeadingAndTrailingWhitespace :: String -> String -stripLeadingAndTrailingWhitespace s = - Strings.fromList (Lists.dropWhile Chars.isSpace (Lists.reverse (Lists.dropWhile Chars.isSpace (Lists.reverse (Strings.toList s))))) - --- | Replace special characters with their alphanumeric aliases -withCharacterAliases :: String -> String -withCharacterAliases original = - - let aliases = - Maps.fromList [ - (32, "sp"), - (33, "excl"), - (34, "quot"), - (35, "num"), - (36, "dollar"), - (37, "percnt"), - (38, "amp"), - (39, "apos"), - (40, "lpar"), - (41, "rpar"), - (42, "ast"), - (43, "plus"), - (44, "comma"), - (45, "minus"), - (46, "period"), - (47, "sol"), - (58, "colon"), - (59, "semi"), - (60, "lt"), - (61, "equals"), - (62, "gt"), - (63, "quest"), - (64, "commat"), - (91, "lsqb"), - (92, "bsol"), - (93, "rsqb"), - (94, "circ"), - (95, "lowbar"), - (96, "grave"), - (123, "lcub"), - (124, "verbar"), - (125, "rcub"), - (126, "tilde")] - alias = \c -> Maybes.fromMaybe (Lists.pure c) (Maybes.map Strings.toList (Maps.lookup c aliases)) - in (Strings.fromList (Lists.filter Chars.isAlphaNum (Lists.concat (Lists.map alias (Strings.toList original))))) - --- | A simple soft line wrap which is suitable for code comments -wrapLine :: Int -> String -> String -wrapLine maxlen input = - - let helper = - \prev -> \rem -> - let trunc = Lists.take maxlen rem - spanResult = - Lists.span (\c -> Logic.and (Logic.not (Equality.equal c 32)) (Logic.not (Equality.equal c 9))) (Lists.reverse trunc) - prefix = Lists.reverse (Pairs.second spanResult) - suffix = Lists.reverse (Pairs.first spanResult) - in (Logic.ifElse (Equality.lte (Lists.length rem) maxlen) (Lists.reverse (Lists.cons rem prev)) (Logic.ifElse (Lists.null prefix) (helper (Lists.cons trunc prev) (Lists.drop maxlen rem)) (helper (Lists.cons (Lists.init prefix) prev) (Lists.concat2 suffix (Lists.drop maxlen rem))))) - in (Strings.fromList (Lists.intercalate [ - 10] (helper [] (Strings.toList input)))) diff --git a/src/gen-main/haskell/Hydra/Graph.hs b/src/gen-main/haskell/Hydra/Graph.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Graph.hs +++ /dev/null @@ -1,89 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | The extension to graphs of Hydra's core type system (hydra.core) - -module Hydra.Graph where - -import qualified Hydra.Context as Context -import qualified Hydra.Core as Core -import qualified Hydra.Errors as Errors -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | A graph, or lexical environment which binds names to terms, types, primitives, and metadata -data Graph = - Graph { - -- | The terms bound by all term variables in scope - graphBoundTerms :: (M.Map Core.Name Core.Term), - -- | The type schemes of all term variables in scope - graphBoundTypes :: (M.Map Core.Name Core.TypeScheme), - -- | A mutable map from type variable names to their accumulated class constraints. This is populated during type inference when operations requiring Eq or Ord are encountered. - graphClassConstraints :: (M.Map Core.Name Core.TypeVariableMetadata), - -- | The set of term variables introduced by specifically by lambdas - graphLambdaVariables :: (S.Set Core.Name), - -- | Any additional metadata bound to term variables in scope - graphMetadata :: (M.Map Core.Name Core.Term), - -- | All primitive functions and constants by name - graphPrimitives :: (M.Map Core.Name Primitive), - -- | All schema types (type schemes) in scope - graphSchemaTypes :: (M.Map Core.Name Core.TypeScheme), - -- | The set of type variables introduced specifically by type lambdas - graphTypeVariables :: (S.Set Core.Name)} - -_Graph = Core.Name "hydra.graph.Graph" - -_Graph_boundTerms = Core.Name "boundTerms" - -_Graph_boundTypes = Core.Name "boundTypes" - -_Graph_classConstraints = Core.Name "classConstraints" - -_Graph_lambdaVariables = Core.Name "lambdaVariables" - -_Graph_metadata = Core.Name "metadata" - -_Graph_primitives = Core.Name "primitives" - -_Graph_schemaTypes = Core.Name "schemaTypes" - -_Graph_typeVariables = Core.Name "typeVariables" - --- | A built-in function or constant -data Primitive = - Primitive { - -- | The unique name of the primitive function - primitiveName :: Core.Name, - -- | The type signature of the primitive function - primitiveType :: Core.TypeScheme, - -- | A concrete implementation of the primitive function. The Context and Graph parameters are needed by higher-order primitives (e.g. lists.map, lists.foldl, eithers.bind) which must evaluate function arguments via term reduction; the Graph provides variable and primitive bindings, while the Context supports tracing and error reporting. - primitiveImplementation :: (Context.Context -> Graph -> [Core.Term] -> Either (Context.InContext Errors.Error) Core.Term)} - -_Primitive = Core.Name "hydra.graph.Primitive" - -_Primitive_name = Core.Name "name" - -_Primitive_type = Core.Name "type" - -_Primitive_implementation = Core.Name "implementation" - --- | A type together with a coder for mapping terms into arguments for primitive functions, and mapping computed results into terms. -data TermCoder a = - TermCoder { - -- | The Hydra type of encoded terms - termCoderType :: Core.Type, - -- | An encode function from terms to native values - termCoderEncode :: (Context.Context -> Graph -> Core.Term -> Either (Context.InContext Errors.Error) a), - -- | A decode function from native values to terms - termCoderDecode :: (Context.Context -> a -> Either (Context.InContext Errors.Error) Core.Term)} - -_TermCoder = Core.Name "hydra.graph.TermCoder" - -_TermCoder_type = Core.Name "type" - -_TermCoder_encode = Core.Name "encode" - -_TermCoder_decode = Core.Name "decode" diff --git a/src/gen-main/haskell/Hydra/Hoisting.hs b/src/gen-main/haskell/Hydra/Hoisting.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Hoisting.hs +++ /dev/null @@ -1,482 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Functions for deep term rewriting operations involving hoisting subterms or bindings into enclosing let terms. - -module Hydra.Hoisting where - -import qualified Hydra.Core as Core -import qualified Hydra.Graph as Graph -import qualified Hydra.Lexical as Lexical -import qualified Hydra.Lib.Equality as Equality -import qualified Hydra.Lib.Lists as Lists -import qualified Hydra.Lib.Literals as Literals -import qualified Hydra.Lib.Logic as Logic -import qualified Hydra.Lib.Maps as Maps -import qualified Hydra.Lib.Math as Math -import qualified Hydra.Lib.Maybes as Maybes -import qualified Hydra.Lib.Pairs as Pairs -import qualified Hydra.Lib.Sets as Sets -import qualified Hydra.Lib.Strings as Strings -import qualified Hydra.Paths as Paths -import qualified Hydra.Rewriting as Rewriting -import qualified Hydra.Schemas as Schemas -import qualified Hydra.Sorting as Sorting -import qualified Hydra.Substitution as Substitution -import qualified Hydra.Typing as Typing -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | Augment bindings with new free variables introduced by substitution, wrapping with lambdas after any type lambdas. -augmentBindingsWithNewFreeVars :: Graph.Graph -> S.Set Core.Name -> [Core.Binding] -> ([Core.Binding], Typing.TermSubst) -augmentBindingsWithNewFreeVars cx boundVars bindings = - - let types = Maps.map Rewriting.typeSchemeToFType (Graph.graphBoundTypes cx) - wrapAfterTypeLambdas = - \vars -> \term -> case term of - Core.TermTypeLambda v0 -> Core.TermTypeLambda (Core.TypeLambda { - Core.typeLambdaParameter = (Core.typeLambdaParameter v0), - Core.typeLambdaBody = (wrapAfterTypeLambdas vars (Core.typeLambdaBody v0))}) - _ -> Lists.foldl (\t -> \p -> Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Pairs.first p), - Core.lambdaDomain = (Pairs.second p), - Core.lambdaBody = t}))) term (Lists.reverse vars) - augment = - \b -> - let freeVars = Sets.toList (Sets.intersection boundVars (Rewriting.freeVariablesInTerm (Core.bindingTerm b))) - varTypePairs = Lists.map (\v -> (v, (Maps.lookup v types))) freeVars - varTypes = Maybes.cat (Lists.map Pairs.second varTypePairs) - in (Logic.ifElse (Logic.or (Lists.null freeVars) (Logic.not (Equality.equal (Lists.length varTypes) (Lists.length varTypePairs)))) (b, Nothing) (Core.Binding { - Core.bindingName = (Core.bindingName b), - Core.bindingTerm = (wrapAfterTypeLambdas varTypePairs (Core.bindingTerm b)), - Core.bindingType = (Maybes.map (\ts -> Core.TypeScheme { - Core.typeSchemeVariables = (Core.typeSchemeVariables ts), - Core.typeSchemeType = (Lists.foldl (\acc -> \t -> Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = t, - Core.functionTypeCodomain = acc})) (Core.typeSchemeType ts) (Lists.reverse varTypes)), - Core.typeSchemeConstraints = (Core.typeSchemeConstraints ts)}) (Core.bindingType b))}, (Just (Core.bindingName b, (Lists.foldl (\t -> \v -> Core.TermApplication (Core.Application { - Core.applicationFunction = t, - Core.applicationArgument = (Core.TermVariable v)})) (Core.TermVariable (Core.bindingName b)) freeVars))))) - results = Lists.map augment bindings - in (Lists.map Pairs.first results, (Typing.TermSubst (Maps.fromList (Maybes.cat (Lists.map Pairs.second results))))) - --- | Check if a binding has a polymorphic type (non-empty list of type scheme variables) -bindingIsPolymorphic :: Core.Binding -> Bool -bindingIsPolymorphic binding = - Maybes.maybe False (\ts -> Logic.not (Lists.null (Core.typeSchemeVariables ts))) (Core.bindingType binding) - --- | Check if a binding's type uses any type variables from the given Graph. Returns True if the free type variables in the binding's type intersect with the type variables in scope (graphTypeVariables). -bindingUsesContextTypeVars :: Graph.Graph -> Core.Binding -> Bool -bindingUsesContextTypeVars cx binding = - Maybes.maybe False (\ts -> - let freeInType = Rewriting.freeVariablesInType (Core.typeSchemeType ts) - contextTypeVars = Graph.graphTypeVariables cx - in (Logic.not (Sets.null (Sets.intersection freeInType contextTypeVars)))) (Core.bindingType binding) - --- | Count the number of occurrences of a variable name in a term. Assumes no variable shadowing. -countVarOccurrences :: Core.Name -> Core.Term -> Int -countVarOccurrences name term = - - let childCount = Lists.foldl (\acc -> \t -> Math.add acc (countVarOccurrences name t)) 0 (Rewriting.subterms term) - in case term of - Core.TermVariable v0 -> Logic.ifElse (Equality.equal v0 name) (Math.add 1 childCount) childCount - _ -> childCount - --- | Transform a let-term by pulling ALL let bindings to the top level. This is useful for targets like Java that don't support nested let expressions at all. If a hoisted binding captures lambda-bound variables from an enclosing scope, the binding is wrapped in lambdas for those variables, and references are replaced with applications. Note: Assumes no variable shadowing; use hydra.rewriting.unshadowVariables first. -hoistAllLetBindings :: Core.Let -> Core.Let -hoistAllLetBindings let0 = - - let emptyCx = - Graph.Graph { - Graph.graphBoundTerms = Maps.empty, - Graph.graphBoundTypes = Maps.empty, - Graph.graphClassConstraints = Maps.empty, - Graph.graphLambdaVariables = Sets.empty, - Graph.graphMetadata = Maps.empty, - Graph.graphPrimitives = Maps.empty, - Graph.graphSchemaTypes = Maps.empty, - Graph.graphTypeVariables = Sets.empty} - in (hoistLetBindingsWithPredicate (\_ -> True) shouldHoistAll emptyCx let0) - --- | Hoist case statements into local let bindings. This is useful for targets such as Python which only support case statements (match) at the top level. Case statements are hoisted only when they appear at non-top-level positions. Top level = root, or reachable through annotations, let body/binding, lambda bodies, or ONE application LHS. Once through an application LHS, lambda bodies no longer count as pass-through. -hoistCaseStatements :: Graph.Graph -> Core.Term -> Core.Term -hoistCaseStatements = hoistSubterms shouldHoistCaseStatement - --- | Hoist case statements into local let bindings for a list of bindings. This version operates prior to inference and uses an empty type context. It hoists case statements and their applied arguments into let bindings. -hoistCaseStatementsInGraph :: [Core.Binding] -> [Core.Binding] -hoistCaseStatementsInGraph bindings = - - let emptyTx = - Graph.Graph { - Graph.graphBoundTerms = Maps.empty, - Graph.graphBoundTypes = Maps.empty, - Graph.graphClassConstraints = Maps.empty, - Graph.graphLambdaVariables = Sets.empty, - Graph.graphMetadata = Maps.empty, - Graph.graphPrimitives = Maps.empty, - Graph.graphSchemaTypes = Maps.empty, - Graph.graphTypeVariables = Sets.empty} - term0 = - Core.TermLet (Core.Let { - Core.letBindings = bindings, - Core.letBody = Core.TermUnit}) - term1 = hoistCaseStatements emptyTx term0 - in (Schemas.termAsBindings term1) - --- | Transform a let-term by pulling polymorphic let bindings to the top level, using Graph. A binding is hoisted if: (1) It is polymorphic (has non-empty typeSchemeVariables), OR (2) Its type uses type variables from the Graph (i.e., from enclosing type lambdas). Bindings which are already at the top level are not hoisted. If a hoisted binding captures lambda-bound or let-bound variables from an enclosing scope, the binding is wrapped in lambdas for those variables, and references are replaced with applications. If a hoisted binding uses type variables from the context, those type variables are added to the binding's type scheme. Note: we assume that there is no variable shadowing; use hydra.rewriting.unshadowVariables first. -hoistLetBindingsWithContext :: (Core.Binding -> Bool) -> Graph.Graph -> Core.Let -> Core.Let -hoistLetBindingsWithContext isParentBinding cx let0 = - hoistLetBindingsWithPredicate isParentBinding shouldHoistPolymorphic cx let0 - --- | Transform a let-term by pulling let bindings to the top level. The isParentBinding predicate applies to top-level bindings and determines whether their subterm bindings are eligible for hoisting. The shouldHoistBinding predicate takes the Graph and a subterm binding, and returns True if the binding should be hoisted. This is useful for targets like Java that cannot have polymorphic definitions in arbitrary positions. The Graph provides information about type variables and lambda variables in scope. If a hoisted binding captures let-bound or lambda-bound variables from an enclosing scope, the binding is wrapped in lambdas for those variables, and references are replaced with applications. If a hoisted binding captures type variables from an enclosing type lambda scope, those type variables are added to the binding's type scheme, and references are replaced with type applications. Note: we assume that there is no variable shadowing; use hydra.rewriting.unshadowVariables first. -hoistLetBindingsWithPredicate :: (Core.Binding -> Bool) -> (Graph.Graph -> Core.Binding -> Bool) -> Graph.Graph -> Core.Let -> Core.Let -hoistLetBindingsWithPredicate isParentBinding shouldHoistBinding cx0 let0 = - - let hoistOne = - \prefix -> \cx -> \pair -> \bindingWithCapturedVars -> - let bindingAndReplacementPairs = Pairs.first pair - alreadyUsedNames = Pairs.second pair - b = Pairs.first bindingWithCapturedVars - capturedTermVars = Pairs.second bindingWithCapturedVars - types = Maps.map Rewriting.typeSchemeToFType (Graph.graphBoundTypes cx) - capturedTermVarTypePairs = Lists.map (\v -> (v, (Maps.lookup v types))) capturedTermVars - capturedTermVarTypes = - Lists.map (\typ -> Rewriting.deannotateTypeParameters typ) (Maybes.cat (Lists.map Pairs.second capturedTermVarTypePairs)) - freeInBindingType = - Maybes.maybe Sets.empty (\ts -> Rewriting.freeVariablesInType (Core.typeSchemeType ts)) (Core.bindingType b) - freeInCapturedVarTypes = Sets.unions (Lists.map (\t -> Rewriting.freeVariablesInType t) capturedTermVarTypes) - capturedTypeVars = - Sets.toList (Sets.intersection (Graph.graphTypeVariables cx) (Sets.union freeInBindingType freeInCapturedVarTypes)) - globalBindingName = - Lexical.chooseUniqueName alreadyUsedNames (Core.Name (Strings.cat2 prefix (Core.unName (Core.bindingName b)))) - newUsedNames = Sets.insert globalBindingName alreadyUsedNames - newTypeScheme = - Logic.ifElse (Equality.equal (Lists.length capturedTermVarTypes) (Lists.length capturedTermVarTypePairs)) (Maybes.map (\ts -> Core.TypeScheme { - Core.typeSchemeVariables = (Lists.nub (Lists.concat2 capturedTypeVars (Core.typeSchemeVariables ts))), - Core.typeSchemeType = (Lists.foldl (\t -> \a -> Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = a, - Core.functionTypeCodomain = t})) (Core.typeSchemeType ts) (Lists.reverse capturedTermVarTypes)), - Core.typeSchemeConstraints = (Core.typeSchemeConstraints ts)}) (Core.bindingType b)) Nothing - strippedTerm = Rewriting.stripTypeLambdas (Core.bindingTerm b) - termWithLambdas = - Lists.foldl (\t -> \p -> Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Pairs.first p), - Core.lambdaDomain = (Maybes.map (\dom -> Rewriting.deannotateTypeParameters dom) (Pairs.second p)), - Core.lambdaBody = t}))) strippedTerm (Lists.reverse capturedTermVarTypePairs) - termWithTypeLambdas = - Lists.foldl (\t -> \v -> Core.TermTypeLambda (Core.TypeLambda { - Core.typeLambdaParameter = v, - Core.typeLambdaBody = t})) termWithLambdas (Lists.reverse (Maybes.maybe [] Core.typeSchemeVariables newTypeScheme)) - withTypeApps = - Lists.foldl (\t -> \v -> Core.TermTypeApplication (Core.TypeApplicationTerm { - Core.typeApplicationTermBody = t, - Core.typeApplicationTermType = (Core.TypeVariable v)})) (Core.TermVariable globalBindingName) capturedTypeVars - replacement = - Lists.foldl (\t -> \v -> Core.TermApplication (Core.Application { - Core.applicationFunction = t, - Core.applicationArgument = (Core.TermVariable v)})) withTypeApps capturedTermVars - newBindingAndReplacement = - (Core.Binding { - Core.bindingName = globalBindingName, - Core.bindingTerm = termWithTypeLambdas, - Core.bindingType = newTypeScheme}, replacement) - newPairs = Lists.cons newBindingAndReplacement bindingAndReplacementPairs - in (newPairs, newUsedNames) - rewrite = - \prefix -> \recurse -> \cx -> \bindingsAndNames -> \term -> - let previouslyFinishedBindings = Pairs.first bindingsAndNames - emptyBindingsAndNames = ([], (Pairs.second bindingsAndNames)) - result = recurse emptyBindingsAndNames term - newBindingsAndNames = Pairs.first result - bindingsSoFar = Pairs.first newBindingsAndNames - alreadyUsedNames = Pairs.second newBindingsAndNames - newTerm = Pairs.second result - in case newTerm of - Core.TermLet v0 -> - let body = Core.letBody v0 - partitionPair = Lists.partition (shouldHoistBinding cx) (Core.letBindings v0) - hoistUs = Pairs.first partitionPair - keepUs = Pairs.second partitionPair - hoistedBindingNames = Lists.map Core.bindingName hoistUs - polyLetVariables = - Sets.fromList (Lists.filter (\v -> Maybes.maybe False Schemas.fTypeIsPolymorphic (Maybes.map Rewriting.typeSchemeToFType (Maps.lookup v (Graph.graphBoundTypes cx)))) (Sets.toList (Sets.difference (Sets.fromList (Maps.keys (Graph.graphBoundTerms cx))) (Graph.graphLambdaVariables cx)))) - boundTermVariables = - Sets.union (Graph.graphLambdaVariables cx) (Sets.difference (Sets.fromList (Maps.keys (Graph.graphBoundTerms cx))) (Graph.graphLambdaVariables cx)) - freeVariablesInEachBinding = - Lists.map (\b -> Sets.toList (Sets.intersection boundTermVariables (Rewriting.freeVariablesInTerm (Core.bindingTerm b)))) hoistUs - bindingDependencies = - Lists.map (\vars -> Lists.partition (\v -> Sets.member v (Sets.fromList hoistedBindingNames)) vars) freeVariablesInEachBinding - bindingEdges = Lists.zip hoistedBindingNames (Lists.map Pairs.first bindingDependencies) - bindingImmediateCapturedVars = Lists.zip hoistedBindingNames (Lists.map Pairs.second bindingDependencies) - capturedVarsMap = Maps.fromList (Sorting.propagateTags bindingEdges bindingImmediateCapturedVars) - bindingsWithCapturedVars = - Lists.map (\b -> (b, (Maybes.maybe [] (\vars -> Sets.toList (Sets.difference vars polyLetVariables)) (Maps.lookup (Core.bindingName b) capturedVarsMap)))) hoistUs - hoistPairsAndNames = Lists.foldl (hoistOne prefix cx) ([], alreadyUsedNames) bindingsWithCapturedVars - hoistPairs = Lists.reverse (Pairs.first hoistPairsAndNames) - hoistedBindings = Lists.map Pairs.first hoistPairs - replacements = Lists.map Pairs.second hoistPairs - finalUsedNames = Pairs.second hoistPairsAndNames - hoistNameReplacementPairs = Lists.zip (Lists.map Core.bindingName hoistUs) replacements - hoistBindingMap = Maps.fromList (Lists.map (\b -> (Core.bindingName b, b)) hoistUs) - isCacheable = - \name -> - let multiRef = Equality.gte (countVarOccurrences name body) 2 - isPoly = Maybes.maybe False (\b -> bindingIsPolymorphic b) (Maps.lookup name hoistBindingMap) - in (Logic.and multiRef (Logic.not isPoly)) - singleRefPairs = Lists.filter (\p -> Logic.not (isCacheable (Pairs.first p))) hoistNameReplacementPairs - multiRefPairs = Lists.filter (\p -> isCacheable (Pairs.first p)) hoistNameReplacementPairs - fullSubst = Typing.TermSubst (Maps.fromList hoistNameReplacementPairs) - bodyOnlySubst = Typing.TermSubst (Maps.fromList singleRefPairs) - bodySubst = Substitution.substituteInTerm bodyOnlySubst body - cacheBindings = - Lists.map (\p -> - let origType = Maybes.maybe Nothing (\b -> Core.bindingType b) (Maps.lookup (Pairs.first p) hoistBindingMap) - in Core.Binding { - Core.bindingName = (Pairs.first p), - Core.bindingTerm = (Pairs.second p), - Core.bindingType = origType}) multiRefPairs - bodyWithCache = - Logic.ifElse (Lists.null cacheBindings) bodySubst (Core.TermLet (Core.Let { - Core.letBindings = cacheBindings, - Core.letBody = bodySubst})) - keepUsSubst = Lists.map (Substitution.substituteInBinding fullSubst) keepUs - hoistedBindingsSubst = Lists.map (Substitution.substituteInBinding fullSubst) hoistedBindings - bindingsSoFarSubst = Lists.map (Substitution.substituteInBinding fullSubst) bindingsSoFar - augmentResult = augmentBindingsWithNewFreeVars cx (Sets.difference boundTermVariables polyLetVariables) bindingsSoFarSubst - bindingsSoFarAugmented = Pairs.first augmentResult - augmentSubst = Pairs.second augmentResult - hoistedBindingsFinal = Lists.map (Substitution.substituteInBinding augmentSubst) hoistedBindingsSubst - bindingsSoFarFinal = Lists.map (Substitution.substituteInBinding augmentSubst) bindingsSoFarAugmented - bodyFinal = Substitution.substituteInTerm augmentSubst bodyWithCache - keepUsFinal = Lists.map (Substitution.substituteInBinding augmentSubst) keepUsSubst - finalTerm = - Logic.ifElse (Lists.null keepUsFinal) bodyFinal (Core.TermLet (Core.Let { - Core.letBindings = keepUsFinal, - Core.letBody = bodyFinal})) - in ((Lists.concat [ - previouslyFinishedBindings, - hoistedBindingsFinal, - bindingsSoFarFinal], finalUsedNames), finalTerm) - _ -> ((Lists.concat2 previouslyFinishedBindings bindingsSoFar, alreadyUsedNames), newTerm) - cx1 = Rewriting.extendGraphForLet (\c -> \b -> Nothing) cx0 let0 - forActiveBinding = - \b -> - let prefix = Strings.cat2 (Core.unName (Core.bindingName b)) "_" - init = ([], (Sets.singleton (Core.bindingName b))) - resultPair = Rewriting.rewriteAndFoldTermWithGraph (rewrite prefix) cx1 init (Core.bindingTerm b) - resultBindings = Pairs.first (Pairs.first resultPair) - resultTerm = Pairs.second resultPair - in (Lists.cons (Core.Binding { - Core.bindingName = (Core.bindingName b), - Core.bindingTerm = resultTerm, - Core.bindingType = (Core.bindingType b)}) resultBindings) - forBinding = \b -> Logic.ifElse (isParentBinding b) (forActiveBinding b) [ - b] - in Core.Let { - Core.letBindings = (Lists.concat (Lists.map forBinding (Core.letBindings let0))), - Core.letBody = (Core.letBody let0)} - --- | Transform a let-term by pulling all polymorphic let bindings to the top level. This is useful to ensure that polymorphic bindings are not nested within other terms, which is unsupported by certain targets such as Java. Polymorphic bindings are those with a non-empty list of type scheme variables. If a hoisted binding captures lambda-bound variables from an enclosing scope, the binding is wrapped in lambdas for those variables, and references are replaced with applications. Note: Assumes no variable shadowing; use hydra.rewriting.unshadowVariables first. -hoistPolymorphicLetBindings :: (Core.Binding -> Bool) -> Core.Let -> Core.Let -hoistPolymorphicLetBindings isParentBinding let0 = - - let emptyCx = - Graph.Graph { - Graph.graphBoundTerms = Maps.empty, - Graph.graphBoundTypes = Maps.empty, - Graph.graphClassConstraints = Maps.empty, - Graph.graphLambdaVariables = Sets.empty, - Graph.graphMetadata = Maps.empty, - Graph.graphPrimitives = Maps.empty, - Graph.graphSchemaTypes = Maps.empty, - Graph.graphTypeVariables = Sets.empty} - in (hoistLetBindingsWithPredicate isParentBinding shouldHoistPolymorphic emptyCx let0) - --- | Hoist subterms into local let bindings based on a path-aware predicate. The predicate receives a pair of (path, term) where path is the list of SubtermSteps from the root to the current term, and returns True if the term should be hoisted. For each let term found, the immediate subterms (binding values and body) are processed: matching subterms within each immediate subterm are collected and hoisted into a local let that wraps that immediate subterm. If a hoisted term contains free variables that are lambda-bound at an enclosing scope, the hoisted binding is wrapped in lambdas for those variables, and the reference is replaced with an application of those variables. -hoistSubterms :: (([Paths.SubtermStep], Core.Term) -> Bool) -> Graph.Graph -> Core.Term -> Core.Term -hoistSubterms shouldHoist cx0 term0 = - - let processImmediateSubterm = - \cx -> \counter -> \namePrefix -> \pathPrefix -> \subterm -> - let baselineLambdaVars = Graph.graphLambdaVariables cx - collectAndReplace = - \recurse -> \path -> \cxInner -> \acc -> \term -> - let currentCounter = Pairs.first acc - collectedBindings = Pairs.second acc - in case term of - Core.TermLet _ -> (acc, term) - Core.TermTypeLambda _ -> (acc, term) - _ -> - let result = recurse acc term - newAcc = Pairs.first result - processedTerm = Pairs.second result - newCounter = Pairs.first newAcc - newBindings = Pairs.second newAcc - fullPath = Lists.concat2 pathPrefix path - in (Logic.ifElse (shouldHoist (fullPath, processedTerm)) ( - let proposedName = - Core.Name (Strings.cat [ - "_hoist_", - namePrefix, - "_", - (Literals.showInt32 newCounter)]) - existingNames = Sets.fromList (Lists.map (\b -> Core.bindingName b) newBindings) - freeVarsInSubterm = Rewriting.freeVariablesInTerm subterm - allReserved = Sets.union existingNames freeVarsInSubterm - bindingName = Lexical.chooseUniqueName allReserved proposedName - allLambdaVars = Graph.graphLambdaVariables cxInner - newLambdaVars = Sets.difference allLambdaVars baselineLambdaVars - freeVars = Rewriting.freeVariablesInTerm processedTerm - capturedVars = Sets.toList (Sets.intersection newLambdaVars freeVars) - typeMap = Maps.map Rewriting.typeSchemeToFType (Graph.graphBoundTypes cxInner) - wrappedTerm = - Lists.foldl (\body -> \varName -> Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = varName, - Core.lambdaDomain = (Maps.lookup varName typeMap), - Core.lambdaBody = body}))) processedTerm (Lists.reverse capturedVars) - reference = - Lists.foldl (\fn -> \varName -> Core.TermApplication (Core.Application { - Core.applicationFunction = fn, - Core.applicationArgument = (Core.TermVariable varName)})) (Core.TermVariable bindingName) capturedVars - newBinding = - Core.Binding { - Core.bindingName = bindingName, - Core.bindingTerm = wrappedTerm, - Core.bindingType = Nothing} - in ((Math.add newCounter 1, (Lists.cons newBinding newBindings)), reference)) (newAcc, processedTerm)) - result = Rewriting.rewriteAndFoldTermWithGraphAndPath collectAndReplace cx (counter, []) subterm - finalAcc = Pairs.first result - transformedSubterm = Pairs.second result - finalCounter = Pairs.first finalAcc - bindings = Pairs.second finalAcc - in (Logic.ifElse (Lists.null bindings) (finalCounter, transformedSubterm) ( - let localLet = - Core.TermLet (Core.Let { - Core.letBindings = (Lists.reverse bindings), - Core.letBody = transformedSubterm}) - in (finalCounter, localLet))) - processLetTerm = - \cx -> \counter -> \path -> \lt -> - let bindings = Core.letBindings lt - body = Core.letBody lt - processBinding = - \acc -> \binding -> - let namePrefix = Strings.intercalate "_" (Strings.splitOn "." (Core.unName (Core.bindingName binding))) - bindingPathPrefix = Lists.concat2 path [ - Paths.SubtermStepLetBinding (Core.bindingName binding)] - result = processImmediateSubterm cx 1 namePrefix bindingPathPrefix (Core.bindingTerm binding) - newValue = Pairs.second result - newBinding = - Core.Binding { - Core.bindingName = (Core.bindingName binding), - Core.bindingTerm = newValue, - Core.bindingType = (Core.bindingType binding)} - in (Lists.cons newBinding acc) - newBindingsReversed = Lists.foldl processBinding [] bindings - newBindings = Lists.reverse newBindingsReversed - bodyPathPrefix = Lists.concat2 path [ - Paths.SubtermStepLetBody] - firstBindingName = - Maybes.maybe "body" (\b -> Strings.intercalate "_" (Strings.splitOn "." (Core.unName (Core.bindingName b)))) (Lists.safeHead bindings) - bodyPrefix = Strings.cat2 firstBindingName "_body" - bodyResult = processImmediateSubterm cx 1 bodyPrefix bodyPathPrefix body - newBody = Pairs.second bodyResult - in (counter, (Core.TermLet (Core.Let { - Core.letBindings = newBindings, - Core.letBody = newBody}))) - rewrite = - \recurse -> \path -> \cx -> \counter -> \term -> case term of - Core.TermLet _ -> - let recursed = recurse counter term - newCounter = Pairs.first recursed - recursedTerm = Pairs.second recursed - in case recursedTerm of - Core.TermLet v1 -> processLetTerm cx newCounter path v1 - _ -> (newCounter, recursedTerm) - _ -> recurse counter term - in (Pairs.second (Rewriting.rewriteAndFoldTermWithGraphAndPath rewrite cx0 1 term0)) - -isApplicationFunction :: Paths.SubtermStep -> Bool -isApplicationFunction acc = - case acc of - Paths.SubtermStepApplicationFunction -> True - _ -> False - --- | Check if a function is a union elimination -isEliminationUnion :: Core.Function -> Bool -isEliminationUnion f = - case f of - Core.FunctionElimination v0 -> case v0 of - Core.EliminationUnion _ -> True - _ -> False - _ -> False - -isLambdaBody :: Paths.SubtermStep -> Bool -isLambdaBody acc = - case acc of - Paths.SubtermStepLambdaBody -> True - _ -> False - --- | Check if a term is a union elimination (case statement) -isUnionElimination :: Core.Term -> Bool -isUnionElimination term = - case term of - Core.TermFunction v0 -> isEliminationUnion v0 - _ -> False - --- | Check if a term is an application of a union elimination (case statement applied to an argument) -isUnionEliminationApplication :: Core.Term -> Bool -isUnionEliminationApplication term = - case term of - Core.TermApplication v0 -> isUnionElimination (Rewriting.deannotateAndDetypeTerm (Core.applicationFunction v0)) - _ -> False - --- | Normalize a path for hoisting by treating immediately-applied lambdas as let bindings. Replaces [applicationFunction, lambdaBody, ...] with [letBody, ...]. -normalizePathForHoisting :: [Paths.SubtermStep] -> [Paths.SubtermStep] -normalizePathForHoisting path = - - let go = - \remaining -> Logic.ifElse (Logic.or (Lists.null remaining) (Lists.null (Lists.tail remaining))) remaining ( - let first = Lists.head remaining - second = Lists.head (Lists.tail remaining) - rest = Lists.tail (Lists.tail remaining) - in (Logic.ifElse (Logic.and (isApplicationFunction first) (isLambdaBody second)) (Lists.cons Paths.SubtermStepLetBody (go rest)) (Lists.cons first (go (Lists.tail remaining))))) - in (go path) - --- | Predicate that always returns True, for hoisting all bindings unconditionally. -shouldHoistAll :: t0 -> t1 -> Bool -shouldHoistAll _ _ = True - --- | Predicate for case statement hoisting. Returns True if term is a union elimination (bare case function) or a case statement application (union elimination applied to an argument) AND not at top level. Top level = reachable through annotations, let body/binding, lambda bodies, or ONE app LHS. Once through an app LHS, lambda bodies no longer pass through. -shouldHoistCaseStatement :: ([Paths.SubtermStep], Core.Term) -> Bool -shouldHoistCaseStatement pathAndTerm = - - let path = Pairs.first pathAndTerm - term = Pairs.second pathAndTerm - in (Logic.ifElse (Logic.not (Logic.or (isUnionElimination term) (isUnionEliminationApplication term))) False ( - let finalState = Lists.foldl (\st -> \acc -> updateHoistState acc st) (True, False) path - in (Logic.not (Pairs.first finalState)))) - --- | Predicate for hoisting polymorphic bindings. Returns True if the binding is polymorphic (has type scheme variables) or if its type uses any type variables from the Graph. -shouldHoistPolymorphic :: Graph.Graph -> Core.Binding -> Bool -shouldHoistPolymorphic cx binding = Logic.or (bindingIsPolymorphic binding) (bindingUsesContextTypeVars cx binding) - --- | Update hoisting state when traversing an accessor. State is (atTopLevel, usedAppLHS). Returns updated state. -updateHoistState :: Paths.SubtermStep -> (Bool, Bool) -> (Bool, Bool) -updateHoistState accessor state = - - let atTop = Pairs.first state - usedApp = Pairs.second state - in (Logic.ifElse (Logic.not atTop) (False, usedApp) (case accessor of - Paths.SubtermStepAnnotatedBody -> (True, usedApp) - Paths.SubtermStepLetBody -> (True, usedApp) - Paths.SubtermStepLetBinding _ -> (True, usedApp) - Paths.SubtermStepLambdaBody -> Logic.ifElse usedApp (False, True) (True, False) - Paths.SubtermStepUnionCasesBranch _ -> Logic.ifElse usedApp (False, True) (True, False) - Paths.SubtermStepUnionCasesDefault -> Logic.ifElse usedApp (False, True) (True, False) - Paths.SubtermStepApplicationFunction -> Logic.ifElse usedApp (False, True) (True, True) - Paths.SubtermStepApplicationArgument -> (False, usedApp) - _ -> (False, usedApp))) diff --git a/src/gen-main/haskell/Hydra/Inference.hs b/src/gen-main/haskell/Hydra/Inference.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Inference.hs +++ /dev/null @@ -1,1130 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Type inference following Algorithm W, extended for nominal terms and types - -module Hydra.Inference where - -import qualified Hydra.Annotations as Annotations -import qualified Hydra.Checking as Checking -import qualified Hydra.Context as Context -import qualified Hydra.Core as Core -import qualified Hydra.Errors as Errors -import qualified Hydra.Extract.Core as Core_ -import qualified Hydra.Graph as Graph -import qualified Hydra.Lexical as Lexical -import qualified Hydra.Lib.Eithers as Eithers -import qualified Hydra.Lib.Equality as Equality -import qualified Hydra.Lib.Lists as Lists -import qualified Hydra.Lib.Literals as Literals -import qualified Hydra.Lib.Logic as Logic -import qualified Hydra.Lib.Maps as Maps -import qualified Hydra.Lib.Math as Math -import qualified Hydra.Lib.Maybes as Maybes -import qualified Hydra.Lib.Pairs as Pairs -import qualified Hydra.Lib.Sets as Sets -import qualified Hydra.Lib.Strings as Strings -import qualified Hydra.Reflect as Reflect -import qualified Hydra.Rewriting as Rewriting -import qualified Hydra.Schemas as Schemas -import qualified Hydra.Show.Core as Core__ -import qualified Hydra.Show.Typing as Typing -import qualified Hydra.Sorting as Sorting -import qualified Hydra.Substitution as Substitution -import qualified Hydra.Typing as Typing_ -import qualified Hydra.Unification as Unification -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | Unify type constraints and check the substitution -bindConstraints :: Context.Context -> Graph.Graph -> [Typing_.TypeConstraint] -> Either (Context.InContext Errors.Error) Typing_.TypeSubst -bindConstraints flowCx cx constraints = - Eithers.bind (Eithers.bimap (\_ic -> Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Errors.unificationErrorMessage (Context.inContextObject _ic)))), - Context.inContextContext = (Context.inContextContext _ic)}) (\_a -> _a) (Unification.unifyTypeConstraints flowCx (Graph.graphSchemaTypes cx) constraints)) (\s -> Eithers.bind (Checking.checkTypeSubst flowCx cx s) (\_ -> Right s)) - --- | Place unbound type variables appearing anywhere under a typed let binding in the type scheme of that binding. These variables may appear in the binding type scheme itself or in that of a subterm, in domain types attached to functions, and in type abstraction and type application terms. This process attempts to capture type variables which have escaped unification, e.g. due to unused code. However, unbound type variables not appearing beneath any typed let binding remain unbound. -bindUnboundTypeVariables :: Graph.Graph -> Core.Term -> Core.Term -bindUnboundTypeVariables cx term0 = - - let svars = Sets.fromList (Maps.keys (Graph.graphSchemaTypes cx)) - rewrite = - \recurse -> \term -> case term of - Core.TermLet v0 -> - let forBinding = - \b -> - let bname = Core.bindingName b - bterm = Core.bindingTerm b - in (Maybes.maybe (Core.Binding { - Core.bindingName = bname, - Core.bindingTerm = (bindUnboundTypeVariables cx bterm), - Core.bindingType = Nothing}) (\ts -> - let bvars = Sets.fromList (Core.typeSchemeVariables ts) - unboundInType = Rewriting.freeVariablesInType (Core.typeSchemeType ts) - unboundInTerm = Rewriting.freeTypeVariablesInTerm bterm - unbound = Sets.toList (Sets.difference (Sets.union unboundInType unboundInTerm) (Sets.union svars bvars)) - ts2 = - Core.TypeScheme { - Core.typeSchemeVariables = (Lists.concat2 (Core.typeSchemeVariables ts) unbound), - Core.typeSchemeType = (Core.typeSchemeType ts), - Core.typeSchemeConstraints = (Core.typeSchemeConstraints ts)} - bterm2 = - Lists.foldl (\t -> \v -> Core.TermTypeLambda (Core.TypeLambda { - Core.typeLambdaParameter = v, - Core.typeLambdaBody = t})) bterm unbound - in Core.Binding { - Core.bindingName = bname, - Core.bindingTerm = bterm2, - Core.bindingType = (Just ts2)}) (Core.bindingType b)) - in (Core.TermLet (Core.Let { - Core.letBindings = (Lists.map forBinding (Core.letBindings v0)), - Core.letBody = (bindUnboundTypeVariables cx (Core.letBody v0))})) - _ -> recurse term - in (Rewriting.rewriteTerm rewrite term0) - --- | Fold a list of type variables over a term to build a type application term -buildTypeApplicationTerm :: [Core.Name] -> Core.Term -> Core.Term -buildTypeApplicationTerm tvars body = - Lists.foldl (\t -> \v -> Core.TermTypeApplication (Core.TypeApplicationTerm { - Core.typeApplicationTermBody = t, - Core.typeApplicationTermType = (Core.TypeVariable v)})) body tvars - --- | Add (term variable, type scheme) pairs to the graph's bound types -extendContext :: [(Core.Name, Core.TypeScheme)] -> Graph.Graph -> Graph.Graph -extendContext pairs cx = - Graph.Graph { - Graph.graphBoundTerms = (Graph.graphBoundTerms cx), - Graph.graphBoundTypes = (Maps.union (Maps.fromList pairs) (Graph.graphBoundTypes cx)), - Graph.graphClassConstraints = (Graph.graphClassConstraints cx), - Graph.graphLambdaVariables = (Graph.graphLambdaVariables cx), - Graph.graphMetadata = (Graph.graphMetadata cx), - Graph.graphPrimitives = (Graph.graphPrimitives cx), - Graph.graphSchemaTypes = (Graph.graphSchemaTypes cx), - Graph.graphTypeVariables = (Graph.graphTypeVariables cx)} - --- | Finalize an inferred term by checking for unbound type variables, then normalizing type variables -finalizeInferredTerm :: Context.Context -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -finalizeInferredTerm flowCx cx term = - - let term2 = bindUnboundTypeVariables cx term - in (Eithers.bind (Checking.checkForUnboundTypeVariables flowCx cx term2) (\_ -> Right (Rewriting.normalizeTypeVariablesInTerm term2))) - --- | Infer a term's type and map over the result -forInferredTerm :: Context.Context -> Graph.Graph -> Core.Term -> String -> (Typing_.InferenceResult -> t0) -> Either (Context.InContext Errors.Error) (t0, Context.Context) -forInferredTerm fcx cx term desc f = - Eithers.bind (inferTypeOfTerm fcx cx term desc) (\rp -> Right (f rp, (Typing_.inferenceResultContext rp))) - --- | Get all free variables in a graph's bound types -freeVariablesInContext :: Graph.Graph -> S.Set Core.Name -freeVariablesInContext cx = - Lists.foldl Sets.union Sets.empty (Lists.map Rewriting.freeVariablesInTypeSchemeSimple (Maps.elems (Graph.graphBoundTypes cx))) - --- | Generate a fresh type variable -freshVariableType :: Context.Context -> (Core.Type, Context.Context) -freshVariableType cx = - - let result = Schemas.freshName cx - name = Pairs.first result - cx2 = Pairs.second result - in (Core.TypeVariable name, cx2) - --- | Generalize a type to a type scheme -generalize :: Graph.Graph -> Core.Type -> Core.TypeScheme -generalize cx typ = - - let isTypeVarName = - \name -> - let parts = Strings.splitOn "." (Core.unName name) - in (Equality.lte (Lists.length parts) 1) - vars = - Lists.nub (Lists.filter (\v -> Logic.and (isUnbound cx v) (isTypeVarName v)) (Rewriting.freeVariablesInTypeOrdered typ)) - allConstraints = Graph.graphClassConstraints cx - relevantConstraints = - Maps.fromList (Maybes.cat (Lists.map (\v -> Maybes.map (\meta -> (v, meta)) (Maps.lookup v allConstraints)) vars)) - constraintsMaybe = Logic.ifElse (Maps.null relevantConstraints) Nothing (Just relevantConstraints) - in Core.TypeScheme { - Core.typeSchemeVariables = vars, - Core.typeSchemeType = typ, - Core.typeSchemeConstraints = constraintsMaybe} - --- | Infer types for all elements in a graph, using the provided ordered bindings. Returns both the inferred graph and the ordered inferred bindings. -inferGraphTypes :: Context.Context -> [Core.Binding] -> Graph.Graph -> Either (Context.InContext Errors.Error) ((Graph.Graph, [Core.Binding]), Context.Context) -inferGraphTypes fcx0 bindings0 g0 = - - let fcx = - Context.Context { - Context.contextTrace = (Lists.cons "graph inference" (Context.contextTrace fcx0)), - Context.contextMessages = (Context.contextMessages fcx0), - Context.contextOther = (Context.contextOther fcx0)} - let0 = - Core.Let { - Core.letBindings = bindings0, - Core.letBody = Core.TermUnit} - fromLetTerm = - \l -> - let bindings = Core.letBindings l - prims = Graph.graphPrimitives g0 - schemaTypes = Graph.graphSchemaTypes g0 - rawG = Lexical.buildGraph bindings Maps.empty prims - g = - Graph.Graph { - Graph.graphBoundTerms = (Graph.graphBoundTerms rawG), - Graph.graphBoundTypes = (Graph.graphBoundTypes rawG), - Graph.graphClassConstraints = (Graph.graphClassConstraints rawG), - Graph.graphLambdaVariables = (Graph.graphLambdaVariables rawG), - Graph.graphMetadata = (Graph.graphMetadata rawG), - Graph.graphPrimitives = (Graph.graphPrimitives rawG), - Graph.graphSchemaTypes = schemaTypes, - Graph.graphTypeVariables = (Graph.graphTypeVariables rawG)} - in (g, bindings) - in (Eithers.bind (inferTypeOfTerm fcx g0 (Core.TermLet let0) "graph term") (\result -> - let fcx2 = Typing_.inferenceResultContext result - term = Typing_.inferenceResultTerm result - in (Eithers.bind (finalizeInferredTerm fcx2 g0 term) (\finalized -> case finalized of - Core.TermLet v0 -> Right (fromLetTerm v0, fcx2) - Core.TermVariable _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError "Expected inferred graph as let term")), - Context.inContextContext = fcx2}))))) - --- | Infer the type of a term in a given inference context -inferInGraphContext :: Context.Context -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) Typing_.InferenceResult -inferInGraphContext fcx cx term = inferTypeOfTerm fcx cx term "single term" - --- | Infer types for multiple terms, propagating class constraints from sub-expressions -inferMany :: Context.Context -> Graph.Graph -> [(Core.Term, String)] -> Either (Context.InContext Errors.Error) (([Core.Term], ([Core.Type], (Typing_.TypeSubst, (M.Map Core.Name Core.TypeVariableMetadata)))), Context.Context) -inferMany fcx cx pairs = - Logic.ifElse (Lists.null pairs) (Right (([], ([], (Substitution.idTypeSubst, Maps.empty))), fcx)) ( - let dflt = - - let e = Pairs.first (Lists.head pairs) - desc = Pairs.second (Lists.head pairs) - tl = Lists.tail pairs - in (Eithers.bind (inferTypeOfTerm fcx cx e desc) (\result1 -> - let fcx2 = Typing_.inferenceResultContext result1 - e1 = Typing_.inferenceResultTerm result1 - t1 = Typing_.inferenceResultType result1 - s1 = Typing_.inferenceResultSubst result1 - c1 = Typing_.inferenceResultClassConstraints result1 - in (Eithers.bind (inferMany fcx2 (Substitution.substInContext s1 cx) tl) (\rp2 -> - let result2 = Pairs.first rp2 - fcx3 = Pairs.second rp2 - e2 = Pairs.first result2 - t2 = Pairs.first (Pairs.second result2) - s2 = Pairs.first (Pairs.second (Pairs.second result2)) - c2 = Pairs.second (Pairs.second (Pairs.second result2)) - c1Subst = Substitution.substInClassConstraints s2 c1 - mergedConstraints = mergeClassConstraints c1Subst c2 - in (Right ((Lists.cons (Substitution.substTypesInTerm s2 e1) e2, (Lists.cons (Substitution.substInType s2 t1) t2, (Substitution.composeTypeSubst s1 s2, mergedConstraints))), fcx3)))))) - in dflt) - --- | Map a possibly untyped term to a fully typed term and its type -inferTypeOf :: Context.Context -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) ((Core.Term, Core.TypeScheme), Context.Context) -inferTypeOf fcx cx term = - - let letTerm = - Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "ignoredVariableName"), - Core.bindingTerm = term, - Core.bindingType = Nothing}], - Core.letBody = (Core.TermLiteral (Core.LiteralString "ignoredBody"))}) - in (Eithers.bind (inferTypeOfTerm fcx cx letTerm "infer type of term") (\result -> - let fcx2 = Typing_.inferenceResultContext result - in (Eithers.bind (finalizeInferredTerm fcx2 cx (Typing_.inferenceResultTerm result)) (\finalized -> Eithers.bind (Core_.let_ fcx2 cx finalized) (\letResult -> - let bindings = Core.letBindings letResult - in (Logic.ifElse (Equality.equal 1 (Lists.length bindings)) ( - let binding = Lists.head bindings - term1 = Core.bindingTerm binding - mts = Core.bindingType binding - in (Maybes.maybe (Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError "Expected a type scheme")), - Context.inContextContext = fcx2})) (\ts -> Right ((term1, ts), fcx2)) mts)) (Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat [ - "Expected a single binding with a type scheme, but got: ", - (Literals.showInt32 (Lists.length bindings)), - " bindings"]))), - Context.inContextContext = fcx2})))))))) - --- | Infer the type of an annotated term (Either version) -inferTypeOfAnnotatedTerm :: Context.Context -> Graph.Graph -> Core.AnnotatedTerm -> Either (Context.InContext Errors.Error) Typing_.InferenceResult -inferTypeOfAnnotatedTerm fcx cx at = - - let term = Core.annotatedTermBody at - ann = Core.annotatedTermAnnotation at - in (Eithers.bind (inferTypeOfTerm fcx cx term "annotated term") (\result -> - let fcx2 = Typing_.inferenceResultContext result - iterm = Typing_.inferenceResultTerm result - itype = Typing_.inferenceResultType result - isubst = Typing_.inferenceResultSubst result - iconstraints = Typing_.inferenceResultClassConstraints result - in (Right (Typing_.InferenceResult { - Typing_.inferenceResultTerm = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = iterm, - Core.annotatedTermAnnotation = ann})), - Typing_.inferenceResultType = itype, - Typing_.inferenceResultSubst = isubst, - Typing_.inferenceResultClassConstraints = iconstraints, - Typing_.inferenceResultContext = fcx2})))) - --- | Infer the type of a function application (Either version) -inferTypeOfApplication :: Context.Context -> Graph.Graph -> Core.Application -> Either (Context.InContext Errors.Error) Typing_.InferenceResult -inferTypeOfApplication fcx0 cx app = - - let fcx = - Context.Context { - Context.contextTrace = (Lists.cons "application" (Context.contextTrace fcx0)), - Context.contextMessages = (Context.contextMessages fcx0), - Context.contextOther = (Context.contextOther fcx0)} - e0 = Core.applicationFunction app - e1 = Core.applicationArgument app - in (Eithers.bind (inferTypeOfTerm fcx cx e0 "lhs") (\lhsResult -> - let fcx2 = Typing_.inferenceResultContext lhsResult - a = Typing_.inferenceResultTerm lhsResult - t0 = Typing_.inferenceResultType lhsResult - s0 = Typing_.inferenceResultSubst lhsResult - c0 = Typing_.inferenceResultClassConstraints lhsResult - in (Eithers.bind (inferTypeOfTerm fcx2 (Substitution.substInContext s0 cx) e1 "rhs") (\rhsResult -> - let fcx3 = Typing_.inferenceResultContext rhsResult - b = Typing_.inferenceResultTerm rhsResult - t1 = Typing_.inferenceResultType rhsResult - s1 = Typing_.inferenceResultSubst rhsResult - c1 = Typing_.inferenceResultClassConstraints rhsResult - vResult = Schemas.freshName fcx3 - v = Pairs.first vResult - fcx4 = Pairs.second vResult - in (Eithers.bind (Eithers.bimap (\_ic -> Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Errors.unificationErrorMessage (Context.inContextObject _ic)))), - Context.inContextContext = (Context.inContextContext _ic)}) (\_a -> _a) (Unification.unifyTypes fcx4 (Graph.graphSchemaTypes cx) (Substitution.substInType s1 t0) (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = t1, - Core.functionTypeCodomain = (Core.TypeVariable v)})) "application lhs")) (\s2 -> Eithers.bind (Checking.checkTypeSubst fcx4 cx s2) (\_ -> - let rExpr = - Core.TermApplication (Core.Application { - Core.applicationFunction = (Substitution.substTypesInTerm (Substitution.composeTypeSubst s1 s2) a), - Core.applicationArgument = (Substitution.substTypesInTerm s2 b)}) - rType = Substitution.substInType s2 (Core.TypeVariable v) - rSubst = - Substitution.composeTypeSubstList [ - s0, - s1, - s2] - c0Subst = Substitution.substInClassConstraints s2 (Substitution.substInClassConstraints s1 c0) - c1Subst = Substitution.substInClassConstraints s2 c1 - rConstraints = mergeClassConstraints c0Subst c1Subst - in (Right (Typing_.InferenceResult { - Typing_.inferenceResultTerm = rExpr, - Typing_.inferenceResultType = rType, - Typing_.inferenceResultSubst = rSubst, - Typing_.inferenceResultClassConstraints = rConstraints, - Typing_.inferenceResultContext = fcx4}))))))))) - --- | Infer the type of a case statement (Either version) -inferTypeOfCaseStatement :: Context.Context -> Graph.Graph -> Core.CaseStatement -> Either (Context.InContext Errors.Error) Typing_.InferenceResult -inferTypeOfCaseStatement fcx cx caseStmt = - - let tname = Core.caseStatementTypeName caseStmt - dflt = Core.caseStatementDefault caseStmt - cases = Core.caseStatementCases caseStmt - fnames = Lists.map Core.fieldName cases - in (Eithers.bind (Schemas.requireSchemaType fcx (Graph.graphSchemaTypes cx) tname) (\stRp -> - let schemaType = Pairs.first stRp - fcx2 = Pairs.second stRp - svars = Core.typeSchemeVariables schemaType - stype = Core.typeSchemeType schemaType - in (Eithers.bind (Core_.unionType fcx2 tname stype) (\sfields -> Eithers.bind (Eithers.mapMaybe (\t -> inferTypeOfTerm fcx2 cx t (Strings.cat [ - "case ", - (Core.unName tname), - "."])) dflt) (\dfltRp -> - let dfltResult = dfltRp - fcx3 = Maybes.fromMaybe fcx2 (Maybes.map Typing_.inferenceResultContext dfltRp) - in (Eithers.bind (inferMany fcx3 cx (Lists.map (\f -> (Core.fieldTerm f, (Strings.cat [ - "case ", - (Core.unName tname), - ".", - (Core.unName (Core.fieldName f))]))) cases)) (\caseRp -> - let caseResults = Pairs.first caseRp - fcx4 = Pairs.second caseRp - iterms = Pairs.first caseResults - itypes = Pairs.first (Pairs.second caseResults) - isubst = Pairs.first (Pairs.second (Pairs.second caseResults)) - caseElemConstraints = Pairs.second (Pairs.second (Pairs.second caseResults)) - codvResult = Schemas.freshName fcx4 - codv = Pairs.first codvResult - fcx5 = Pairs.second codvResult - cod = Core.TypeVariable codv - caseMap = Maps.fromList (Lists.map (\ft -> (Core.fieldTypeName ft, (Core.fieldTypeType ft))) sfields) - dfltConstraints = - Maybes.toList (Maybes.map (\r -> Typing_.TypeConstraint { - Typing_.typeConstraintLeft = cod, - Typing_.typeConstraintRight = (Substitution.substInType isubst (Typing_.inferenceResultType r)), - Typing_.typeConstraintComment = "match default"}) dfltResult) - caseConstraints = - Maybes.cat (Lists.zipWith (\fname -> \itype -> Maybes.map (\ftype -> Typing_.TypeConstraint { - Typing_.typeConstraintLeft = itype, - Typing_.typeConstraintRight = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = ftype, - Core.functionTypeCodomain = cod})), - Typing_.typeConstraintComment = "case type"}) (Maps.lookup fname caseMap)) fnames itypes) - dfltClassConstraints = Maybes.fromMaybe Maps.empty (Maybes.map Typing_.inferenceResultClassConstraints dfltResult) - allElemConstraints = mergeClassConstraints caseElemConstraints dfltClassConstraints - in (Eithers.bind (mapConstraints fcx5 cx (\subst -> yieldWithConstraints fcx5 (buildTypeApplicationTerm svars (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = tname, - Core.caseStatementDefault = (Maybes.map Typing_.inferenceResultTerm dfltResult), - Core.caseStatementCases = (Lists.zipWith (\n -> \t -> Core.Field { - Core.fieldName = n, - Core.fieldTerm = t}) fnames iterms)}))))) (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Schemas.nominalApplication tname (Lists.map (\x -> Core.TypeVariable x) svars)), - Core.functionTypeCodomain = cod})) (Substitution.composeTypeSubstList (Lists.concat [ - Maybes.toList (Maybes.map Typing_.inferenceResultSubst dfltResult), - [ - isubst, - subst]])) (Substitution.substInClassConstraints subst allElemConstraints)) (Lists.concat [ - dfltConstraints, - caseConstraints])) (\mcResult -> Right mcResult))))))))) - --- | Infer the type of a collection. The classNames parameter specifies type classes (e.g. ordering) that the element type variable must satisfy. -inferTypeOfCollection :: Context.Context -> Graph.Graph -> (Core.Type -> Core.Type) -> ([Core.Term] -> Core.Term) -> String -> S.Set Core.Name -> [Core.Term] -> Either (Context.InContext Errors.Error) Typing_.InferenceResult -inferTypeOfCollection fcx cx typCons trmCons desc classNames els = - - let varResult = Schemas.freshName fcx - var = Pairs.first varResult - fcx2 = Pairs.second varResult - classConstraints = - Logic.ifElse (Sets.null classNames) Maps.empty (Maps.singleton var (Core.TypeVariableMetadata { - Core.typeVariableMetadataClasses = classNames})) - in (Logic.ifElse (Lists.null els) (Right (yieldWithConstraints fcx2 (buildTypeApplicationTerm [ - var] (trmCons [])) (typCons (Core.TypeVariable var)) Substitution.idTypeSubst classConstraints)) (Eithers.bind (inferMany fcx2 cx (Lists.zip els (Lists.map (\i -> Strings.cat [ - "#", - (Literals.showInt32 i)]) (Math.range 1 (Math.add (Lists.length els) 1))))) (\resultsRp -> - let results = Pairs.first resultsRp - fcx3 = Pairs.second resultsRp - terms = Pairs.first results - types = Pairs.first (Pairs.second results) - subst1 = Pairs.first (Pairs.second (Pairs.second results)) - elemConstraints = Pairs.second (Pairs.second (Pairs.second results)) - constraints = - Lists.map (\t -> Typing_.TypeConstraint { - Typing_.typeConstraintLeft = (Core.TypeVariable var), - Typing_.typeConstraintRight = t, - Typing_.typeConstraintComment = desc}) types - allConstraints = mergeClassConstraints classConstraints elemConstraints - in (Eithers.bind (mapConstraints fcx3 cx (\subst2 -> - let iterm = trmCons terms - itype = typCons (Core.TypeVariable var) - isubst = Substitution.composeTypeSubst subst1 subst2 - in (yieldWithConstraints fcx3 iterm itype isubst (Substitution.substInClassConstraints subst2 allConstraints))) constraints) (\mcResult -> Right mcResult))))) - --- | Infer the type of an either value (Either version) -inferTypeOfEither :: Context.Context -> Graph.Graph -> Either Core.Term Core.Term -> Either (Context.InContext Errors.Error) Typing_.InferenceResult -inferTypeOfEither fcx cx e = - Eithers.either (\l -> Eithers.bind (inferTypeOfTerm fcx cx l "either left value") (\r1 -> - let fcx2 = Typing_.inferenceResultContext r1 - iterm = Typing_.inferenceResultTerm r1 - leftType = Typing_.inferenceResultType r1 - subst = Typing_.inferenceResultSubst r1 - fvResult = freshVariableType fcx2 - rightType = Pairs.first fvResult - fcx3 = Pairs.second fvResult - eitherTerm = Core.TermEither (Left iterm) - termWithLeftType = - Core.TermTypeApplication (Core.TypeApplicationTerm { - Core.typeApplicationTermBody = eitherTerm, - Core.typeApplicationTermType = leftType}) - termWithBothTypes = - Core.TermTypeApplication (Core.TypeApplicationTerm { - Core.typeApplicationTermBody = termWithLeftType, - Core.typeApplicationTermType = rightType}) - eitherType = - Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = leftType, - Core.eitherTypeRight = rightType}) - in (Right (yieldChecked fcx3 termWithBothTypes eitherType subst)))) (\r -> Eithers.bind (inferTypeOfTerm fcx cx r "either right value") (\r1 -> - let fcx2 = Typing_.inferenceResultContext r1 - iterm = Typing_.inferenceResultTerm r1 - rightType = Typing_.inferenceResultType r1 - subst = Typing_.inferenceResultSubst r1 - fvResult = freshVariableType fcx2 - leftType = Pairs.first fvResult - fcx3 = Pairs.second fvResult - eitherTerm = Core.TermEither (Right iterm) - termWithLeftType = - Core.TermTypeApplication (Core.TypeApplicationTerm { - Core.typeApplicationTermBody = eitherTerm, - Core.typeApplicationTermType = leftType}) - termWithBothTypes = - Core.TermTypeApplication (Core.TypeApplicationTerm { - Core.typeApplicationTermBody = termWithLeftType, - Core.typeApplicationTermType = rightType}) - eitherType = - Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = leftType, - Core.eitherTypeRight = rightType}) - in (Right (yieldChecked fcx3 termWithBothTypes eitherType subst)))) e - --- | Infer the type of an elimination (Either version) -inferTypeOfElimination :: Context.Context -> Graph.Graph -> Core.Elimination -> Either (Context.InContext Errors.Error) Typing_.InferenceResult -inferTypeOfElimination fcx cx elm = - case elm of - Core.EliminationRecord v0 -> inferTypeOfProjection fcx cx v0 - Core.EliminationUnion v0 -> inferTypeOfCaseStatement fcx cx v0 - Core.EliminationWrap v0 -> inferTypeOfUnwrap fcx cx v0 - --- | Infer the type of a function (Either version) -inferTypeOfFunction :: Context.Context -> Graph.Graph -> Core.Function -> Either (Context.InContext Errors.Error) Typing_.InferenceResult -inferTypeOfFunction fcx cx f = - case f of - Core.FunctionElimination v0 -> inferTypeOfElimination fcx cx v0 - Core.FunctionLambda v0 -> inferTypeOfLambda fcx cx v0 - Core.FunctionPrimitive v0 -> inferTypeOfPrimitive fcx cx v0 - --- | Infer the type of a union injection (Either version) -inferTypeOfInjection :: Context.Context -> Graph.Graph -> Core.Injection -> Either (Context.InContext Errors.Error) Typing_.InferenceResult -inferTypeOfInjection fcx cx injection = - - let tname = Core.injectionTypeName injection - field = Core.injectionField injection - fname = Core.fieldName field - term = Core.fieldTerm field - in (Eithers.bind (inferTypeOfTerm fcx cx term "injected term") (\result -> - let fcx2 = Typing_.inferenceResultContext result - in (Eithers.bind (Schemas.requireSchemaType fcx2 (Graph.graphSchemaTypes cx) tname) (\stRp -> - let schemaType = Pairs.first stRp - fcx3 = Pairs.second stRp - svars = Core.typeSchemeVariables schemaType - stype = Core.typeSchemeType schemaType - iterm = Typing_.inferenceResultTerm result - ityp = Typing_.inferenceResultType result - isubst = Typing_.inferenceResultSubst result - in (Eithers.bind (Core_.unionType fcx3 tname stype) (\sfields -> Eithers.bind (Schemas.findFieldType fcx3 fname sfields) (\ftyp -> Eithers.bind (mapConstraints fcx3 cx (\subst -> yield fcx3 (buildTypeApplicationTerm svars (Core.TermUnion (Core.Injection { - Core.injectionTypeName = tname, - Core.injectionField = Core.Field { - Core.fieldName = fname, - Core.fieldTerm = iterm}}))) (Schemas.nominalApplication tname (Lists.map (\x -> Core.TypeVariable x) svars)) (Substitution.composeTypeSubst isubst subst)) [ - Typing_.TypeConstraint { - Typing_.typeConstraintLeft = ftyp, - Typing_.typeConstraintRight = ityp, - Typing_.typeConstraintComment = "schema type of injected field"}]) (\mcResult -> Right mcResult)))))))) - --- | Infer the type of a lambda function (Either version) -inferTypeOfLambda :: Context.Context -> Graph.Graph -> Core.Lambda -> Either (Context.InContext Errors.Error) Typing_.InferenceResult -inferTypeOfLambda fcx cx lambda = - - let var = Core.lambdaParameter lambda - body = Core.lambdaBody lambda - vdomResult = Schemas.freshName fcx - vdom = Pairs.first vdomResult - fcx2 = Pairs.second vdomResult - dom = Core.TypeVariable vdom - cx2 = - extendContext [ - (var, Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = dom, - Core.typeSchemeConstraints = Nothing})] cx - in (Eithers.bind (inferTypeOfTerm fcx2 cx2 body "lambda body") (\result -> - let fcx3 = Typing_.inferenceResultContext result - iterm = Typing_.inferenceResultTerm result - icod = Typing_.inferenceResultType result - isubst = Typing_.inferenceResultSubst result - rdom = Substitution.substInType isubst dom - rterm = - Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = var, - Core.lambdaDomain = (Just rdom), - Core.lambdaBody = iterm})) - rtype = - Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = rdom, - Core.functionTypeCodomain = icod}) - vars = - Sets.unions [ - Rewriting.freeVariablesInType rdom, - (Rewriting.freeVariablesInType icod), - (freeVariablesInContext (Substitution.substInContext isubst cx2))] - cx3 = Substitution.substInContext isubst cx - iconstraints = Substitution.substInClassConstraints isubst (Typing_.inferenceResultClassConstraints result) - in (Right (Typing_.InferenceResult { - Typing_.inferenceResultTerm = rterm, - Typing_.inferenceResultType = rtype, - Typing_.inferenceResultSubst = isubst, - Typing_.inferenceResultClassConstraints = iconstraints, - Typing_.inferenceResultContext = fcx3})))) - --- | Normalize a let term before inferring its type (Either version) -inferTypeOfLet :: Context.Context -> Graph.Graph -> Core.Let -> Either (Context.InContext Errors.Error) Typing_.InferenceResult -inferTypeOfLet fcx0 cx let0 = - - let fcx = - Context.Context { - Context.contextTrace = (Lists.cons "let" (Context.contextTrace fcx0)), - Context.contextMessages = (Context.contextMessages fcx0), - Context.contextOther = (Context.contextOther fcx0)} - bindings0 = Core.letBindings let0 - body0 = Core.letBody let0 - names = Lists.map Core.bindingName bindings0 - nameSet = Sets.fromList names - toPair = - \binding -> - let name = Core.bindingName binding - term = Core.bindingTerm binding - in (name, (Lists.filter (\n -> Sets.member n nameSet) (Sets.toList (Rewriting.freeVariablesInTerm term)))) - adjList = Lists.map toPair bindings0 - groups = Sorting.topologicalSortComponents adjList - bindingMap = Maps.fromList (Lists.zip names bindings0) - createLet = - \e -> \group -> Core.TermLet (Core.Let { - Core.letBindings = (Maybes.cat (Lists.map (\n -> Maps.lookup n bindingMap) group)), - Core.letBody = e}) - rewrittenLet = Lists.foldl createLet body0 (Lists.reverse groups) - restoreLet = - \iterm -> - let helper = - \level -> \bins -> \term -> - let nonzero = - \term -> case term of - Core.TermLet v0 -> - let bs = Core.letBindings v0 - letBody = Core.letBody v0 - in (helper (Math.sub level 1) (Lists.concat [ - bs, - bins]) letBody) - in (Logic.ifElse (Equality.equal level 0) (bins, term) (nonzero term)) - result = helper (Lists.length groups) [] iterm - bindingList = Pairs.first result - e = Pairs.second result - bindingMap2 = Maps.fromList (Lists.map (\b -> (Core.bindingName b, b)) bindingList) - in (Core.TermLet (Core.Let { - Core.letBindings = (Maybes.cat (Lists.map (\n -> Maps.lookup n bindingMap2) names)), - Core.letBody = e})) - rewriteResult = - \iresult -> - let fcxR = Typing_.inferenceResultContext iresult - iterm = Typing_.inferenceResultTerm iresult - itype = Typing_.inferenceResultType iresult - isubst = Typing_.inferenceResultSubst iresult - iconstraints = Typing_.inferenceResultClassConstraints iresult - in Typing_.InferenceResult { - Typing_.inferenceResultTerm = (restoreLet iterm), - Typing_.inferenceResultType = itype, - Typing_.inferenceResultSubst = isubst, - Typing_.inferenceResultClassConstraints = iconstraints, - Typing_.inferenceResultContext = fcxR} - res = - case rewrittenLet of - Core.TermLet v0 -> inferTypeOfLetNormalized fcx cx v0 - _ -> inferTypeOfTerm fcx cx rewrittenLet "empty let term" - in (Eithers.map rewriteResult res) - --- | Infer the type of a let (letrec) term which is already in a normal form (Either version) -inferTypeOfLetNormalized :: Context.Context -> Graph.Graph -> Core.Let -> Either (Context.InContext Errors.Error) Typing_.InferenceResult -inferTypeOfLetNormalized fcx0 cx0 letTerm = - - let fcx = - Context.Context { - Context.contextTrace = (Lists.cons "let-normalized" (Context.contextTrace fcx0)), - Context.contextMessages = (Context.contextMessages fcx0), - Context.contextOther = (Context.contextOther fcx0)} - bins0 = Core.letBindings letTerm - body0 = Core.letBody letTerm - bnames = Lists.map Core.bindingName bins0 - bvarsResult = Schemas.freshNames (Lists.length bins0) fcx - bvars = Pairs.first bvarsResult - fcx2 = Pairs.second bvarsResult - tbins0 = Lists.map (\x -> Core.TypeVariable x) bvars - cx1 = - extendContext (Lists.zip bnames (Lists.map (\t -> Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = t, - Core.typeSchemeConstraints = Nothing}) tbins0)) cx0 - in (Eithers.bind (inferTypesOfTemporaryBindings fcx2 cx1 bins0) (\irRp -> - let inferredResult = Pairs.first irRp - fcx3 = Pairs.second irRp - bterms1 = Pairs.first inferredResult - tbins1 = Pairs.first (Pairs.second inferredResult) - substAndConstraints = Pairs.second (Pairs.second inferredResult) - s1 = Pairs.first substAndConstraints - inferredConstraints = Pairs.second substAndConstraints - in (Eithers.bind (Eithers.bimap (\_ic -> Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Errors.unificationErrorMessage (Context.inContextObject _ic)))), - Context.inContextContext = (Context.inContextContext _ic)}) (\_a -> _a) (Unification.unifyTypeLists fcx3 (Graph.graphSchemaTypes cx0) (Lists.map (Substitution.substInType s1) tbins0) tbins1 "temporary type bindings")) (\s2 -> Eithers.bind (Checking.checkTypeSubst fcx3 cx0 s2) (\_ -> - let g2base = Substitution.substInContext (Substitution.composeTypeSubst s1 s2) cx0 - constraintsWithS2 = Substitution.substInClassConstraints s2 inferredConstraints - composedSubst = Substitution.composeTypeSubst s1 s2 - originalBindingConstraints = - Lists.foldl (\acc -> \b -> Maybes.maybe acc (\ts -> Maybes.maybe acc (\c -> mergeClassConstraints acc c) (Core.typeSchemeConstraints ts)) (Core.bindingType b)) Maps.empty bins0 - originalConstraintsSubst = Substitution.substInClassConstraints composedSubst originalBindingConstraints - allInferredConstraints = mergeClassConstraints constraintsWithS2 originalConstraintsSubst - mergedConstraints = mergeClassConstraints (Graph.graphClassConstraints g2base) allInferredConstraints - g2 = - Graph.Graph { - Graph.graphBoundTerms = (Graph.graphBoundTerms g2base), - Graph.graphBoundTypes = (Graph.graphBoundTypes g2base), - Graph.graphClassConstraints = mergedConstraints, - Graph.graphLambdaVariables = (Graph.graphLambdaVariables g2base), - Graph.graphMetadata = (Graph.graphMetadata g2base), - Graph.graphPrimitives = (Graph.graphPrimitives g2base), - Graph.graphSchemaTypes = (Graph.graphSchemaTypes g2base), - Graph.graphTypeVariables = (Graph.graphTypeVariables g2base)} - bterms1Subst = Lists.map (Substitution.substTypesInTerm s2) bterms1 - tsbins1 = Lists.zip bnames (Lists.map (\t -> generalize g2 (Substitution.substInType s2 t)) tbins1) - in (Eithers.bind (inferTypeOfTerm fcx3 (extendContext tsbins1 g2) body0 "let body") (\bodyResult -> - let fcx4 = Typing_.inferenceResultContext bodyResult - body1 = Typing_.inferenceResultTerm bodyResult - tbody = Typing_.inferenceResultType bodyResult - sbody = Typing_.inferenceResultSubst bodyResult - st1 = - Typing_.TermSubst (Maps.fromList (Lists.map (\pair -> - let name = Pairs.first pair - ts = Pairs.second pair - in (name, (buildTypeApplicationTerm (Core.typeSchemeVariables ts) (Core.TermVariable name)))) tsbins1)) - createBinding = - \bindingPair -> - let nameTsPair = Pairs.first bindingPair - term = Pairs.second bindingPair - name = Pairs.first nameTsPair - ts = Pairs.second nameTsPair - finalTs = Substitution.substInTypeScheme sbody ts - typeLambdaTerm = - Lists.foldl (\b -> \v -> Core.TermTypeLambda (Core.TypeLambda { - Core.typeLambdaParameter = v, - Core.typeLambdaBody = b})) (Substitution.substituteInTerm st1 term) (Lists.reverse (Core.typeSchemeVariables finalTs)) - in Core.Binding { - Core.bindingName = name, - Core.bindingTerm = (Substitution.substTypesInTerm (Substitution.composeTypeSubst sbody s2) typeLambdaTerm), - Core.bindingType = (Just finalTs)} - bins1 = Lists.map createBinding (Lists.zip tsbins1 bterms1Subst) - bodyConstraints = Substitution.substInClassConstraints sbody (Typing_.inferenceResultClassConstraints bodyResult) - bindingConstraintsSubst = Substitution.substInClassConstraints sbody constraintsWithS2 - allConstraints = mergeClassConstraints bindingConstraintsSubst bodyConstraints - in (Right (Typing_.InferenceResult { - Typing_.inferenceResultTerm = (Core.TermLet (Core.Let { - Core.letBindings = bins1, - Core.letBody = body1})), - Typing_.inferenceResultType = tbody, - Typing_.inferenceResultSubst = (Substitution.composeTypeSubstList [ - s1, - s2, - sbody]), - Typing_.inferenceResultClassConstraints = allConstraints, - Typing_.inferenceResultContext = fcx4}))))))))) - --- | Infer the type of a list (Either version) -inferTypeOfList :: Context.Context -> Graph.Graph -> [Core.Term] -> Either (Context.InContext Errors.Error) Typing_.InferenceResult -inferTypeOfList fcx cx = - inferTypeOfCollection fcx cx (\x -> Core.TypeList x) (\x -> Core.TermList x) "list element" Sets.empty - --- | Infer the type of a literal -inferTypeOfLiteral :: Context.Context -> Core.Literal -> Typing_.InferenceResult -inferTypeOfLiteral fcx lit = - Typing_.InferenceResult { - Typing_.inferenceResultTerm = (Core.TermLiteral lit), - Typing_.inferenceResultType = (Core.TypeLiteral (Reflect.literalType lit)), - Typing_.inferenceResultSubst = Substitution.idTypeSubst, - Typing_.inferenceResultClassConstraints = Maps.empty, - Typing_.inferenceResultContext = fcx} - --- | Infer the type of a map (Either version) -inferTypeOfMap :: Context.Context -> Graph.Graph -> M.Map Core.Term Core.Term -> Either (Context.InContext Errors.Error) Typing_.InferenceResult -inferTypeOfMap fcx cx m = - - let kvarResult = Schemas.freshName fcx - kvar = Pairs.first kvarResult - fcx2 = Pairs.second kvarResult - vvarResult = Schemas.freshName fcx2 - vvar = Pairs.first vvarResult - fcx3 = Pairs.second vvarResult - keyConstraints = - Maps.singleton kvar (Core.TypeVariableMetadata { - Core.typeVariableMetadataClasses = (Sets.singleton (Core.Name "ordering"))}) - in (Logic.ifElse (Maps.null m) (Right (yieldWithConstraints fcx3 (buildTypeApplicationTerm [ - kvar, - vvar] (Core.TermMap Maps.empty)) (Core.TypeMap (Core.MapType { - Core.mapTypeKeys = (Core.TypeVariable kvar), - Core.mapTypeValues = (Core.TypeVariable vvar)})) Substitution.idTypeSubst keyConstraints)) (Eithers.bind (inferMany fcx3 cx (Lists.map (\k -> (k, "map key")) (Maps.keys m))) (\kRp -> - let kResults = Pairs.first kRp - fcx4 = Pairs.second kRp - kterms = Pairs.first kResults - ktypes = Pairs.first (Pairs.second kResults) - ksubst = Pairs.first (Pairs.second (Pairs.second kResults)) - kElemConstraints = Pairs.second (Pairs.second (Pairs.second kResults)) - in (Eithers.bind (inferMany fcx4 (Substitution.substInContext ksubst cx) (Lists.map (\v -> (v, "map value")) (Maps.elems m))) (\vRp -> - let vResults = Pairs.first vRp - fcx5 = Pairs.second vRp - vterms = Pairs.first vResults - vtypes = Pairs.first (Pairs.second vResults) - vsubst = Pairs.first (Pairs.second (Pairs.second vResults)) - vElemConstraints = Pairs.second (Pairs.second (Pairs.second vResults)) - kcons = - Lists.map (\t -> Typing_.TypeConstraint { - Typing_.typeConstraintLeft = (Core.TypeVariable kvar), - Typing_.typeConstraintRight = t, - Typing_.typeConstraintComment = "map key"}) ktypes - vcons = - Lists.map (\t -> Typing_.TypeConstraint { - Typing_.typeConstraintLeft = (Core.TypeVariable vvar), - Typing_.typeConstraintRight = t, - Typing_.typeConstraintComment = "map value"}) vtypes - allMapConstraints = mergeClassConstraints keyConstraints (mergeClassConstraints kElemConstraints vElemConstraints) - in (Eithers.bind (mapConstraints fcx5 cx (\subst -> yieldWithConstraints fcx5 (Core.TermMap (Maps.fromList (Lists.zip kterms vterms))) (Core.TypeMap (Core.MapType { - Core.mapTypeKeys = (Core.TypeVariable kvar), - Core.mapTypeValues = (Core.TypeVariable vvar)})) (Substitution.composeTypeSubstList [ - ksubst, - vsubst, - subst]) (Substitution.substInClassConstraints subst allMapConstraints)) (Lists.concat [ - kcons, - vcons])) (\mcResult -> Right mcResult))))))) - --- | Infer the type of an optional (Either version) -inferTypeOfOptional :: Context.Context -> Graph.Graph -> Maybe Core.Term -> Either (Context.InContext Errors.Error) Typing_.InferenceResult -inferTypeOfOptional fcx cx m = - - let trmCons = \terms -> Logic.ifElse (Lists.null terms) (Core.TermMaybe Nothing) (Core.TermMaybe (Just (Lists.head terms))) - in (inferTypeOfCollection fcx cx (\x -> Core.TypeMaybe x) trmCons "optional element" Sets.empty (Maybes.maybe [] Lists.singleton m)) - --- | Infer the type of a pair (Either version) -inferTypeOfPair :: Context.Context -> Graph.Graph -> (Core.Term, Core.Term) -> Either (Context.InContext Errors.Error) Typing_.InferenceResult -inferTypeOfPair fcx cx p = - Eithers.bind (inferMany fcx cx [ - (Pairs.first p, "pair first element"), - (Pairs.second p, "pair second element")]) (\rp -> - let results = Pairs.first rp - fcx2 = Pairs.second rp - iterms = Pairs.first results - itypes = Pairs.first (Pairs.second results) - isubst = Pairs.first (Pairs.second (Pairs.second results)) - pairElemConstraints = Pairs.second (Pairs.second (Pairs.second results)) - ifst = Lists.head iterms - isnd = Lists.head (Lists.tail iterms) - tyFst = Lists.head itypes - tySnd = Lists.head (Lists.tail itypes) - pairTerm = Core.TermPair (ifst, isnd) - termWithTypes = - Core.TermTypeApplication (Core.TypeApplicationTerm { - Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm { - Core.typeApplicationTermBody = pairTerm, - Core.typeApplicationTermType = tyFst})), - Core.typeApplicationTermType = tySnd}) - in (Right (yieldWithConstraints fcx2 termWithTypes (Core.TypePair (Core.PairType { - Core.pairTypeFirst = tyFst, - Core.pairTypeSecond = tySnd})) isubst pairElemConstraints))) - --- | Infer the type of a primitive function (Either version) -inferTypeOfPrimitive :: Context.Context -> Graph.Graph -> Core.Name -> Either (Context.InContext Errors.Error) Typing_.InferenceResult -inferTypeOfPrimitive fcx cx name = - Maybes.maybe (Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 "No such primitive: " (Core.unName name)))), - Context.inContextContext = fcx})) (\scheme -> - let tsResult = Schemas.instantiateTypeScheme fcx scheme - ts = Pairs.first tsResult - fcx2 = Pairs.second tsResult - constraints = Maybes.fromMaybe Maps.empty (Core.typeSchemeConstraints ts) - in (Right (yieldCheckedWithConstraints fcx2 (buildTypeApplicationTerm (Core.typeSchemeVariables ts) (Core.TermFunction (Core.FunctionPrimitive name))) (Core.typeSchemeType ts) Substitution.idTypeSubst constraints))) (Maybes.map Graph.primitiveType (Maps.lookup name (Graph.graphPrimitives cx))) - --- | Infer the type of a record projection (Either version) -inferTypeOfProjection :: Context.Context -> Graph.Graph -> Core.Projection -> Either (Context.InContext Errors.Error) Typing_.InferenceResult -inferTypeOfProjection fcx cx proj = - - let tname = Core.projectionTypeName proj - fname = Core.projectionField proj - in (Eithers.bind (Schemas.requireSchemaType fcx (Graph.graphSchemaTypes cx) tname) (\stRp -> - let schemaType = Pairs.first stRp - fcx2 = Pairs.second stRp - svars = Core.typeSchemeVariables schemaType - stype = Core.typeSchemeType schemaType - in (Eithers.bind (Core_.recordType fcx2 tname stype) (\sfields -> Eithers.bind (Schemas.findFieldType fcx2 fname sfields) (\ftyp -> Right (yield fcx2 (buildTypeApplicationTerm svars (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = tname, - Core.projectionField = fname}))))) (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Schemas.nominalApplication tname (Lists.map (\x -> Core.TypeVariable x) svars)), - Core.functionTypeCodomain = ftyp})) Substitution.idTypeSubst)))))) - --- | Infer the type of a record (Either version) -inferTypeOfRecord :: Context.Context -> Graph.Graph -> Core.Record -> Either (Context.InContext Errors.Error) Typing_.InferenceResult -inferTypeOfRecord fcx cx record = - - let tname = Core.recordTypeName record - fields = Core.recordFields record - fnames = Lists.map Core.fieldName fields - in (Eithers.bind (Schemas.requireSchemaType fcx (Graph.graphSchemaTypes cx) tname) (\stRp -> - let schemaType = Pairs.first stRp - fcx2 = Pairs.second stRp - in (Eithers.bind (inferMany fcx2 cx (Lists.map (\f -> (Core.fieldTerm f, (Strings.cat2 "field " (Core.unName (Core.fieldName f))))) fields)) (\rp -> - let results = Pairs.first rp - fcx3 = Pairs.second rp - svars = Core.typeSchemeVariables schemaType - stype = Core.typeSchemeType schemaType - iterms = Pairs.first results - itypes = Pairs.first (Pairs.second results) - isubst = Pairs.first (Pairs.second (Pairs.second results)) - recElemConstraints = Pairs.second (Pairs.second (Pairs.second results)) - ityp = - Core.TypeRecord (Lists.zipWith (\n -> \t -> Core.FieldType { - Core.fieldTypeName = n, - Core.fieldTypeType = t}) fnames itypes) - in (Eithers.bind (mapConstraints fcx3 cx (\subst -> yieldWithConstraints fcx3 (buildTypeApplicationTerm svars (Core.TermRecord (Core.Record { - Core.recordTypeName = tname, - Core.recordFields = (Lists.zipWith (\n -> \t -> Core.Field { - Core.fieldName = n, - Core.fieldTerm = t}) fnames iterms)}))) (Schemas.nominalApplication tname (Lists.map (\x -> Core.TypeVariable x) svars)) (Substitution.composeTypeSubst isubst subst) (Substitution.substInClassConstraints subst recElemConstraints)) [ - Typing_.TypeConstraint { - Typing_.typeConstraintLeft = stype, - Typing_.typeConstraintRight = ityp, - Typing_.typeConstraintComment = "schema type of record"}]) (\mcResult -> Right mcResult)))))) - --- | Infer the type of a set (Either version) -inferTypeOfSet :: Context.Context -> Graph.Graph -> S.Set Core.Term -> Either (Context.InContext Errors.Error) Typing_.InferenceResult -inferTypeOfSet fcx cx s = - inferTypeOfCollection fcx cx (\x -> Core.TypeSet x) (\terms -> Core.TermSet (Sets.fromList terms)) "set element" (Sets.singleton (Core.Name "ordering")) (Sets.toList s) - --- | Infer the type of a given term (Either version) -inferTypeOfTerm :: Context.Context -> Graph.Graph -> Core.Term -> String -> Either (Context.InContext Errors.Error) Typing_.InferenceResult -inferTypeOfTerm fcx cx term desc = - - let fcx2 = - Context.Context { - Context.contextTrace = (Lists.cons desc (Context.contextTrace fcx)), - Context.contextMessages = (Context.contextMessages fcx), - Context.contextOther = (Context.contextOther fcx)} - in case term of - Core.TermAnnotated v0 -> inferTypeOfAnnotatedTerm fcx2 cx v0 - Core.TermApplication v0 -> inferTypeOfApplication fcx2 cx v0 - Core.TermEither v0 -> inferTypeOfEither fcx2 cx v0 - Core.TermFunction v0 -> inferTypeOfFunction fcx2 cx v0 - Core.TermLet v0 -> inferTypeOfLet fcx2 cx v0 - Core.TermList v0 -> inferTypeOfList fcx2 cx v0 - Core.TermLiteral v0 -> Right (inferTypeOfLiteral fcx2 v0) - Core.TermMap v0 -> inferTypeOfMap fcx2 cx v0 - Core.TermMaybe v0 -> inferTypeOfOptional fcx2 cx v0 - Core.TermPair v0 -> inferTypeOfPair fcx2 cx v0 - Core.TermRecord v0 -> inferTypeOfRecord fcx2 cx v0 - Core.TermSet v0 -> inferTypeOfSet fcx2 cx v0 - Core.TermTypeApplication v0 -> inferTypeOfTypeApplication fcx2 cx v0 - Core.TermTypeLambda v0 -> inferTypeOfTypeLambda fcx2 cx v0 - Core.TermUnion v0 -> inferTypeOfInjection fcx2 cx v0 - Core.TermUnit -> Right (inferTypeOfUnit fcx2) - Core.TermVariable v0 -> inferTypeOfVariable fcx2 cx v0 - Core.TermWrap v0 -> inferTypeOfWrappedTerm fcx2 cx v0 - --- | Infer the type of a type application (Either version) -inferTypeOfTypeApplication :: Context.Context -> Graph.Graph -> Core.TypeApplicationTerm -> Either (Context.InContext Errors.Error) Typing_.InferenceResult -inferTypeOfTypeApplication fcx cx tt = inferTypeOfTerm fcx cx (Core.typeApplicationTermBody tt) "type application term" - --- | Infer the type of a type abstraction (Either version) -inferTypeOfTypeLambda :: Context.Context -> Graph.Graph -> Core.TypeLambda -> Either (Context.InContext Errors.Error) Typing_.InferenceResult -inferTypeOfTypeLambda fcx cx ta = inferTypeOfTerm fcx cx (Core.typeLambdaBody ta) "type abstraction" - --- | The trivial inference rule for the unit term -inferTypeOfUnit :: Context.Context -> Typing_.InferenceResult -inferTypeOfUnit fcx = - Typing_.InferenceResult { - Typing_.inferenceResultTerm = Core.TermUnit, - Typing_.inferenceResultType = Core.TypeUnit, - Typing_.inferenceResultSubst = Substitution.idTypeSubst, - Typing_.inferenceResultClassConstraints = Maps.empty, - Typing_.inferenceResultContext = fcx} - --- | Infer the type of an unwrap operation (Either version) -inferTypeOfUnwrap :: Context.Context -> Graph.Graph -> Core.Name -> Either (Context.InContext Errors.Error) Typing_.InferenceResult -inferTypeOfUnwrap fcx cx tname = - Eithers.bind (Schemas.requireSchemaType fcx (Graph.graphSchemaTypes cx) tname) (\stRp -> - let schemaType = Pairs.first stRp - fcx2 = Pairs.second stRp - svars = Core.typeSchemeVariables schemaType - stype = Core.typeSchemeType schemaType - in (Eithers.bind (Core_.wrappedType fcx2 tname stype) (\wtyp -> Right (yield fcx2 (buildTypeApplicationTerm svars (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap tname)))) (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Schemas.nominalApplication tname (Lists.map (\x -> Core.TypeVariable x) svars)), - Core.functionTypeCodomain = wtyp})) Substitution.idTypeSubst)))) - --- | Infer the type of a variable (Either version) -inferTypeOfVariable :: Context.Context -> Graph.Graph -> Core.Name -> Either (Context.InContext Errors.Error) Typing_.InferenceResult -inferTypeOfVariable fcx cx name = - Maybes.maybe (Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 "Variable not bound to type: " (Core.unName name)))), - Context.inContextContext = fcx})) (\scheme -> - let tsResult = Schemas.instantiateTypeScheme fcx scheme - ts = Pairs.first tsResult - fcx2 = Pairs.second tsResult - constraints = Maybes.fromMaybe Maps.empty (Core.typeSchemeConstraints ts) - in (Right (Typing_.InferenceResult { - Typing_.inferenceResultTerm = (buildTypeApplicationTerm (Core.typeSchemeVariables ts) (Core.TermVariable name)), - Typing_.inferenceResultType = (Core.typeSchemeType ts), - Typing_.inferenceResultSubst = Substitution.idTypeSubst, - Typing_.inferenceResultClassConstraints = constraints, - Typing_.inferenceResultContext = fcx2}))) (Maps.lookup name (Graph.graphBoundTypes cx)) - --- | Infer the type of a wrapped term (Either version) -inferTypeOfWrappedTerm :: Context.Context -> Graph.Graph -> Core.WrappedTerm -> Either (Context.InContext Errors.Error) Typing_.InferenceResult -inferTypeOfWrappedTerm fcx cx wt = - - let tname = Core.wrappedTermTypeName wt - term = Core.wrappedTermBody wt - in (Eithers.bind (Schemas.requireSchemaType fcx (Graph.graphSchemaTypes cx) tname) (\stRp -> - let schemaType = Pairs.first stRp - fcx2 = Pairs.second stRp - in (Eithers.bind (inferTypeOfTerm fcx2 cx term "wrapped term") (\result -> - let fcx3 = Typing_.inferenceResultContext result - svars = Core.typeSchemeVariables schemaType - stype = Core.typeSchemeType schemaType - iterm = Typing_.inferenceResultTerm result - itype = Typing_.inferenceResultType result - isubst = Typing_.inferenceResultSubst result - ityp = Core.TypeWrap itype - in (Eithers.bind (mapConstraints fcx3 cx (\subst -> yield fcx3 (buildTypeApplicationTerm svars (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = tname, - Core.wrappedTermBody = iterm}))) (Schemas.nominalApplication tname (Lists.map (\x -> Core.TypeVariable x) svars)) (Substitution.composeTypeSubst isubst subst)) [ - Typing_.TypeConstraint { - Typing_.typeConstraintLeft = stype, - Typing_.typeConstraintRight = ityp, - Typing_.typeConstraintComment = "schema type of wrapper"}]) (\mcResult -> Right mcResult)))))) - --- | Infer types for temporary let bindings (Either version) -inferTypesOfTemporaryBindings :: Context.Context -> Graph.Graph -> [Core.Binding] -> Either (Context.InContext Errors.Error) (([Core.Term], ([Core.Type], (Typing_.TypeSubst, (M.Map Core.Name Core.TypeVariableMetadata)))), Context.Context) -inferTypesOfTemporaryBindings fcx cx bins = - Logic.ifElse (Lists.null bins) (Right (([], ([], (Substitution.idTypeSubst, Maps.empty))), fcx)) ( - let dflt = - - let binding = Lists.head bins - k = Core.bindingName binding - v = Core.bindingTerm binding - tl = Lists.tail bins - in (Eithers.bind (inferTypeOfTerm fcx cx v (Strings.cat [ - "temporary let binding '", - (Core.unName k), - "'"])) (\result1 -> - let fcx2 = Typing_.inferenceResultContext result1 - j = Typing_.inferenceResultTerm result1 - u_prime = Typing_.inferenceResultType result1 - u = Typing_.inferenceResultSubst result1 - c1Inferred = Typing_.inferenceResultClassConstraints result1 - in (Eithers.bind (Maybes.maybe (Right Maps.empty) (\ts -> - let tsResult = Schemas.instantiateTypeScheme fcx2 ts - instantiatedTs = Pairs.first tsResult - freshConstraints = Maybes.fromMaybe Maps.empty (Core.typeSchemeConstraints instantiatedTs) - in (Eithers.bind (Eithers.bimap (\_ic -> Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Errors.unificationErrorMessage (Context.inContextObject _ic)))), - Context.inContextContext = (Context.inContextContext _ic)}) (\_a -> _a) (Unification.unifyTypes fcx2 (Graph.graphSchemaTypes cx) (Core.typeSchemeType instantiatedTs) u_prime "original binding type")) (\unifySubst -> Right (Substitution.substInClassConstraints unifySubst freshConstraints)))) (Core.bindingType binding)) (\originalBindingConstraints -> - let c1 = mergeClassConstraints c1Inferred originalBindingConstraints - in (Eithers.bind (inferTypesOfTemporaryBindings fcx2 (Substitution.substInContext u cx) tl) (\rp2 -> - let result2 = Pairs.first rp2 - fcx3 = Pairs.second rp2 - h = Pairs.first result2 - r_prime = Pairs.first (Pairs.second result2) - restPair = Pairs.second (Pairs.second result2) - r = Pairs.first restPair - c2 = Pairs.second restPair - c1Subst = Substitution.substInClassConstraints r c1 - mergedConstraints = mergeClassConstraints c1Subst c2 - in (Right ((Lists.cons (Substitution.substTypesInTerm r j) h, (Lists.cons (Substitution.substInType r u_prime) r_prime, (Substitution.composeTypeSubst u r, mergedConstraints))), fcx3)))))))) - in dflt) - --- | Check if a variable is unbound in context -isUnbound :: Graph.Graph -> Core.Name -> Bool -isUnbound cx v = - Logic.and (Logic.not (Sets.member v (freeVariablesInContext cx))) (Logic.not (Maps.member v (Graph.graphSchemaTypes cx))) - --- | Map over type constraints after unification -mapConstraints :: Context.Context -> Graph.Graph -> (Typing_.TypeSubst -> t0) -> [Typing_.TypeConstraint] -> Either (Context.InContext Errors.Error) t0 -mapConstraints flowCx cx f constraints = - Eithers.bind (Eithers.bimap (\_ic -> Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Errors.unificationErrorMessage (Context.inContextObject _ic)))), - Context.inContextContext = (Context.inContextContext _ic)}) (\_a -> _a) (Unification.unifyTypeConstraints flowCx (Graph.graphSchemaTypes cx) constraints)) (\s -> Eithers.bind (Checking.checkTypeSubst flowCx cx s) (\_ -> Right (f s))) - --- | Merge two maps of class constraints. When both maps have constraints for the same variable, union the class sets. -mergeClassConstraints :: Ord t0 => (M.Map t0 Core.TypeVariableMetadata -> M.Map t0 Core.TypeVariableMetadata -> M.Map t0 Core.TypeVariableMetadata) -mergeClassConstraints m1 m2 = - Lists.foldl (\acc -> \pair -> - let k = Pairs.first pair - v = Pairs.second pair - in (Maybes.maybe (Maps.insert k v acc) (\existing -> - let merged = - Core.TypeVariableMetadata { - Core.typeVariableMetadataClasses = (Sets.union (Core.typeVariableMetadataClasses existing) (Core.typeVariableMetadataClasses v))} - in (Maps.insert k merged acc)) (Maps.lookup k acc))) m1 (Maps.toList m2) - --- | Show an inference result for debugging -showInferenceResult :: Typing_.InferenceResult -> String -showInferenceResult result = - - let term = Typing_.inferenceResultTerm result - typ = Typing_.inferenceResultType result - subst = Typing_.inferenceResultSubst result - in (Strings.cat [ - "{term=", - (Core__.term term), - ", type=", - (Core__.type_ typ), - ", subst=", - (Typing.typeSubst subst), - "}"]) - --- | Create an inference result with no class constraints -yield :: Context.Context -> Core.Term -> Core.Type -> Typing_.TypeSubst -> Typing_.InferenceResult -yield fcx term typ subst = - Typing_.InferenceResult { - Typing_.inferenceResultTerm = (Substitution.substTypesInTerm subst term), - Typing_.inferenceResultType = (Substitution.substInType subst typ), - Typing_.inferenceResultSubst = subst, - Typing_.inferenceResultClassConstraints = Maps.empty, - Typing_.inferenceResultContext = fcx} - --- | Create a checked inference result -yieldChecked :: Context.Context -> Core.Term -> Core.Type -> Typing_.TypeSubst -> Typing_.InferenceResult -yieldChecked fcx term typ subst = - - let iterm = Substitution.substTypesInTerm subst term - itype = Substitution.substInType subst typ - in Typing_.InferenceResult { - Typing_.inferenceResultTerm = iterm, - Typing_.inferenceResultType = itype, - Typing_.inferenceResultSubst = subst, - Typing_.inferenceResultClassConstraints = Maps.empty, - Typing_.inferenceResultContext = fcx} - --- | Create a checked inference result with class constraints -yieldCheckedWithConstraints :: Context.Context -> Core.Term -> Core.Type -> Typing_.TypeSubst -> M.Map Core.Name Core.TypeVariableMetadata -> Typing_.InferenceResult -yieldCheckedWithConstraints fcx term typ subst constraints = - - let iterm = Substitution.substTypesInTerm subst term - itype = Substitution.substInType subst typ - iconstraints = Substitution.substInClassConstraints subst constraints - in Typing_.InferenceResult { - Typing_.inferenceResultTerm = iterm, - Typing_.inferenceResultType = itype, - Typing_.inferenceResultSubst = subst, - Typing_.inferenceResultClassConstraints = iconstraints, - Typing_.inferenceResultContext = fcx} - --- | Create an inference result with debug output -yieldDebug :: Context.Context -> t0 -> String -> Core.Term -> Core.Type -> Typing_.TypeSubst -> Either (Context.InContext Errors.Error) Typing_.InferenceResult -yieldDebug fcx cx debugId term typ subst = - - let rterm = Substitution.substTypesInTerm subst term - rtyp = Substitution.substInType subst typ - in (Eithers.bind (Annotations.debugIf fcx debugId (Strings.cat [ - "\n\tterm: ", - (Core__.term term), - "\n\ttyp: ", - (Core__.type_ typ), - "\n\tsubst: ", - (Typing.typeSubst subst), - "\n\trterm: ", - (Core__.term rterm), - "\n\trtyp: ", - (Core__.type_ rtyp)])) (\result -> Right (Typing_.InferenceResult { - Typing_.inferenceResultTerm = rterm, - Typing_.inferenceResultType = rtyp, - Typing_.inferenceResultSubst = subst, - Typing_.inferenceResultClassConstraints = Maps.empty, - Typing_.inferenceResultContext = fcx}))) - --- | Create an inference result with class constraints -yieldWithConstraints :: Context.Context -> Core.Term -> Core.Type -> Typing_.TypeSubst -> M.Map Core.Name Core.TypeVariableMetadata -> Typing_.InferenceResult -yieldWithConstraints fcx term typ subst constraints = - Typing_.InferenceResult { - Typing_.inferenceResultTerm = (Substitution.substTypesInTerm subst term), - Typing_.inferenceResultType = (Substitution.substInType subst typ), - Typing_.inferenceResultSubst = subst, - Typing_.inferenceResultClassConstraints = constraints, - Typing_.inferenceResultContext = fcx} diff --git a/src/gen-main/haskell/Hydra/Json/Bootstrap.hs b/src/gen-main/haskell/Hydra/Json/Bootstrap.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Json/Bootstrap.hs +++ /dev/null @@ -1,1672 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | A module which provides a minimal typing environment for decoding other modules from JSON. This avoids certain problems with generating entire source modules into target languages like Java, which is subject to method size limits for large modules like hydra.core. - -module Hydra.Json.Bootstrap where - -import qualified Hydra.Core as Core -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -typesByName :: M.Map Core.Name Core.Type -typesByName = - M.fromList [ - (Core.Name "hydra.coders.AdapterContext", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeRecord [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "graph"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The underlying graph of elements and primitives")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "language"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.coders.Language")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The language being encoded or decoded")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "adapters"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeMap (Core.MapType { - Core.mapTypeKeys = (Core.TypeVariable (Core.Name "hydra.core.Name")), - Core.mapTypeValues = (Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.util.Adapter")), - Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "hydra.core.Type"))})), - Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "hydra.core.Type"))})), - Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "hydra.core.Term"))})), - Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "hydra.core.Term"))}))})), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A map of type names to adapters for those types")))])}))}]), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "An evaluation context together with a source language and a target language")))])}))), - (Core.Name "hydra.coders.CoderDirection", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeUnion [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "encode"), - Core.fieldTypeType = Core.TypeUnit}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "decode"), - Core.fieldTypeType = Core.TypeUnit}]), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "Indicates either the 'out' or the 'in' direction of a coder")))])}))), - (Core.Name "hydra.coders.Language", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeRecord [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "name"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.coders.LanguageName")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The unique name of the language")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "constraints"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.coders.LanguageConstraints")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The constraints which characterize the language")))])}))}]), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A named language together with language-specific constraints")))])}))), - (Core.Name "hydra.coders.LanguageConstraints", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeRecord [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "eliminationVariants"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeSet (Core.TypeVariable (Core.Name "hydra.variants.EliminationVariant"))), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "All supported elimination variants")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "literalVariants"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeSet (Core.TypeVariable (Core.Name "hydra.variants.LiteralVariant"))), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "All supported literal variants")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "floatTypes"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeSet (Core.TypeVariable (Core.Name "hydra.core.FloatType"))), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "All supported float types")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "functionVariants"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeSet (Core.TypeVariable (Core.Name "hydra.variants.FunctionVariant"))), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "All supported function variants")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "integerTypes"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeSet (Core.TypeVariable (Core.Name "hydra.core.IntegerType"))), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "All supported integer types")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "termVariants"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeSet (Core.TypeVariable (Core.Name "hydra.variants.TermVariant"))), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "All supported term variants")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "typeVariants"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeSet (Core.TypeVariable (Core.Name "hydra.variants.TypeVariant"))), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "All supported type variants")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "types"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Type")), - Core.functionTypeCodomain = (Core.TypeLiteral Core.LiteralTypeBoolean)})), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A logical set of types, as a predicate which tests a type for inclusion")))])}))}]), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A set of constraints on valid type and term expressions, characterizing a language")))])}))), - (Core.Name "hydra.coders.LanguageName", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeWrap (Core.TypeLiteral Core.LiteralTypeString)), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The unique name of a language")))])}))), - (Core.Name "hydra.coders.SymmetricAdapter", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeForall (Core.ForallType { - Core.forallTypeParameter = (Core.Name "t"), - Core.forallTypeBody = (Core.TypeForall (Core.ForallType { - Core.forallTypeParameter = (Core.Name "v"), - Core.forallTypeBody = (Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.util.Adapter")), - Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "t"))})), - Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "t"))})), - Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "v"))})), - Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "v"))}))}))})), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A bidirectional encoder which maps between the same type and term languages on either side")))])}))), - (Core.Name "hydra.coders.TraversalOrder", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeUnion [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "pre"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = Core.TypeUnit, - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "Pre-order traversal")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "post"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = Core.TypeUnit, - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "Post-order traversal")))])}))}]), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "Specifies either a pre-order or post-order traversal")))])}))), - (Core.Name "hydra.coders.TypeAdapter", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.coders.AdapterContext")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Type")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeLiteral Core.LiteralTypeString), - Core.eitherTypeRight = (Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.coders.SymmetricAdapter")), - Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "hydra.core.Type"))})), - Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "hydra.core.Term"))}))}))}))})), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A function which maps a Hydra type to a symmetric adapter between types and terms")))])}))), - (Core.Name "hydra.context.Context", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeRecord [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "trace"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeList (Core.TypeLiteral Core.LiteralTypeString)), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A stack of context labels describing the current execution path")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "messages"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeList (Core.TypeLiteral Core.LiteralTypeString)), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A log of warnings and/or info messages")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "other"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeMap (Core.MapType { - Core.mapTypeKeys = (Core.TypeVariable (Core.Name "hydra.core.Name")), - Core.mapTypeValues = (Core.TypeVariable (Core.Name "hydra.core.Term"))})), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A map of string keys to arbitrary terms as values, for application-specific use")))])}))}]), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "An execution context for tracing and diagnostics, threaded through function calls")))])}))), - (Core.Name "hydra.context.InContext", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeForall (Core.ForallType { - Core.forallTypeParameter = (Core.Name "e"), - Core.forallTypeBody = (Core.TypeRecord [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "object"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "e")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A domain object; typically an error")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "context"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.context.Context")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The execution context at the point of capture")))])}))}])})), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A particular domain object (such as an error) together with an execution context")))])}))), - (Core.Name "hydra.core.AnnotatedTerm", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeRecord [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "body"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The term being annotated")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "annotation"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeMap (Core.MapType { - Core.mapTypeKeys = (Core.TypeVariable (Core.Name "hydra.core.Name")), - Core.mapTypeValues = (Core.TypeVariable (Core.Name "hydra.core.Term"))})), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The annotation as a map from keys to values")))])}))}]), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A term together with an annotation")))])}))), - (Core.Name "hydra.core.AnnotatedType", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeRecord [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "body"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The type being annotated")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "annotation"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeMap (Core.MapType { - Core.mapTypeKeys = (Core.TypeVariable (Core.Name "hydra.core.Name")), - Core.mapTypeValues = (Core.TypeVariable (Core.Name "hydra.core.Term"))})), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The annotation as a map from keys to values")))])}))}]), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A type together with an annotation")))])}))), - (Core.Name "hydra.core.Application", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeRecord [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "function"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The left-hand side of the application")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "argument"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The right-hand side of the application")))])}))}]), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A term which applies a function to an argument")))])}))), - (Core.Name "hydra.core.ApplicationType", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeRecord [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "function"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The left-hand side of the application")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "argument"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The right-hand side of the application")))])}))}]), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The type-level analog of an application term")))])}))), - (Core.Name "hydra.core.Binding", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeRecord [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "name"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Name")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The name of the bound variable")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "term"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The term to which the variable is bound")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "type"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeMaybe (Core.TypeVariable (Core.Name "hydra.core.TypeScheme"))), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The optional type of the bound term")))])}))}]), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A field with an optional type scheme, used to bind variables to terms in a 'let' expression")))])}))), - (Core.Name "hydra.core.CaseStatement", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeRecord [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "typeName"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Name")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The name of the union type")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "default"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeMaybe (Core.TypeVariable (Core.Name "hydra.core.Term"))), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "An optional default case, used if none of the explicit cases match")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "cases"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeList (Core.TypeVariable (Core.Name "hydra.core.Field"))), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A list of case alternatives, one per union field")))])}))}]), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A union elimination; a case statement")))])}))), - (Core.Name "hydra.core.EitherType", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeRecord [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "left"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The 'left' alternative")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "right"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The 'right' alternative")))])}))}]), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A type which provides a choice between a 'left' type and a 'right' type")))])}))), - (Core.Name "hydra.core.Elimination", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeUnion [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "record"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Projection")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "Eliminates a record by projecting a given field")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "union"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.CaseStatement")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "Eliminates a union term by matching over the fields of the union. This is a case statement.")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "wrap"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Name")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "Unwrap a wrapped term")))])}))}]), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A corresponding elimination for an introduction term")))])}))), - (Core.Name "hydra.core.Field", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeRecord [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "name"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Name")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The name of the field")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "term"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The term value of the field")))])}))}]), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A name/term pair")))])}))), - (Core.Name "hydra.core.FieldType", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeRecord [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "name"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Name")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The name of the field")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "type"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The type of the field")))])}))}]), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A name/type pair")))])}))), - (Core.Name "hydra.core.FloatType", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeUnion [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "bigfloat"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = Core.TypeUnit, - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "An arbitrary-precision floating-point type")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "float32"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = Core.TypeUnit, - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A 32-bit floating-point type")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "float64"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = Core.TypeUnit, - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A 64-bit floating-point type")))])}))}]), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A floating-point type")))])}))), - (Core.Name "hydra.core.FloatValue", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeUnion [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "bigfloat"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeBigfloat)), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "An arbitrary-precision floating-point value")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "float32"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat32)), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A 32-bit floating-point value")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "float64"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64)), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A 64-bit floating-point value")))])}))}]), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A floating-point literal value")))])}))), - (Core.Name "hydra.core.ForallType", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeRecord [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "parameter"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Name")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The variable which is bound by the lambda")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "body"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The body of the lambda")))])}))}]), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A universally quantified type; the System F equivalent of a type scheme, and the type-level equivalent of a lambda term.")))])}))), - (Core.Name "hydra.core.Function", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeUnion [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "elimination"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Elimination")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "An elimination for any of a few term variants")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "lambda"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Lambda")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A function abstraction (lambda)")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "primitive"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Name")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A reference to a built-in (primitive) function")))])}))}]), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A function")))])}))), - (Core.Name "hydra.core.FunctionType", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeRecord [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "domain"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The domain (input) type of the function")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "codomain"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The codomain (output) type of the function")))])}))}]), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A function type, also known as an arrow type")))])}))), - (Core.Name "hydra.core.Injection", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeRecord [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "typeName"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Name")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The name of the union type")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "field"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Field")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The field being injected, including its name and value")))])}))}]), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "An instance of a union type; i.e. a string-indexed generalization of inl() or inr()")))])}))), - (Core.Name "hydra.core.IntegerType", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeUnion [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "bigint"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = Core.TypeUnit, - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "An arbitrary-precision integer type")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "int8"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = Core.TypeUnit, - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "An 8-bit signed integer type")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "int16"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = Core.TypeUnit, - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A 16-bit signed integer type")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "int32"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = Core.TypeUnit, - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A 32-bit signed integer type")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "int64"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = Core.TypeUnit, - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A 64-bit signed integer type")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "uint8"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = Core.TypeUnit, - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "An 8-bit unsigned integer type")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "uint16"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = Core.TypeUnit, - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A 16-bit unsigned integer type")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "uint32"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = Core.TypeUnit, - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A 32-bit unsigned integer type")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "uint64"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = Core.TypeUnit, - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A 64-bit unsigned integer type")))])}))}]), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "An integer type")))])}))), - (Core.Name "hydra.core.IntegerValue", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeUnion [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "bigint"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeBigint)), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "An arbitrary-precision integer value")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "int8"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt8)), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "An 8-bit signed integer value")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "int16"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt16)), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A 16-bit signed integer value (short value)")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "int32"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32)), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A 32-bit signed integer value (int value)")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "int64"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt64)), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A 64-bit signed integer value (long value)")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "uint8"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeUint8)), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "An 8-bit unsigned integer value (byte)")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "uint16"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeUint16)), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A 16-bit unsigned integer value")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "uint32"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeUint32)), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A 32-bit unsigned integer value (unsigned int)")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "uint64"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeUint64)), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A 64-bit unsigned integer value (unsigned long)")))])}))}]), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "An integer literal value")))])}))), - (Core.Name "hydra.core.Lambda", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeRecord [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "parameter"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Name")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The parameter of the lambda")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "domain"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeMaybe (Core.TypeVariable (Core.Name "hydra.core.Type"))), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "An optional domain type for the lambda")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "body"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The body of the lambda")))])}))}]), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A function abstraction (lambda)")))])}))), - (Core.Name "hydra.core.Let", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeRecord [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "bindings"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeList (Core.TypeVariable (Core.Name "hydra.core.Binding"))), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The list of variable bindings")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "body"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The body term in which the variables are bound")))])}))}]), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A set of (possibly recursive) 'let' bindings together with a body in which they are bound")))])}))), - (Core.Name "hydra.core.Literal", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeUnion [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "binary"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeLiteral Core.LiteralTypeBinary), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A binary literal")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "boolean"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeLiteral Core.LiteralTypeBoolean), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A boolean literal")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "float"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.FloatValue")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A floating-point literal")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "integer"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.IntegerValue")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "An integer literal")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "string"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeLiteral Core.LiteralTypeString), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A string literal")))])}))}]), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A term constant; an instance of a literal type")))])}))), - (Core.Name "hydra.core.LiteralType", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeUnion [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "binary"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = Core.TypeUnit, - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The type of a binary (byte string) value")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "boolean"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = Core.TypeUnit, - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The type of a boolean (true/false) value")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "float"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.FloatType")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The type of a floating-point value")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "integer"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.IntegerType")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The type of an integer value")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "string"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = Core.TypeUnit, - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The type of a string value")))])}))}]), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "Any of a fixed set of literal types, also called atomic types, base types, primitive types, or type constants")))])}))), - (Core.Name "hydra.core.MapType", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeRecord [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "keys"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The type of keys in the map")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "values"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The type of values in the map")))])}))}]), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A map type")))])}))), - (Core.Name "hydra.core.Name", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeWrap (Core.TypeLiteral Core.LiteralTypeString)), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A unique identifier in some context; a string-valued key")))])}))), - (Core.Name "hydra.core.PairType", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeRecord [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "first"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The first component of the pair")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "second"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The second component of the pair")))])}))}]), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A type which pairs a 'first' type and a 'second' type")))])}))), - (Core.Name "hydra.core.Projection", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeRecord [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "typeName"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Name")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The name of the record type")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "field"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Name")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The name of the projected field")))])}))}]), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A record elimination; a projection")))])}))), - (Core.Name "hydra.core.Record", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeRecord [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "typeName"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Name")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The name of the record type")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "fields"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeList (Core.TypeVariable (Core.Name "hydra.core.Field"))), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The fields of the record, as a list of name/term pairs")))])}))}]), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A record, or labeled tuple; a map of field names to terms")))])}))), - (Core.Name "hydra.core.Term", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeUnion [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "annotated"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.AnnotatedTerm")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A term annotated with metadata")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "application"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Application")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A function application")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "either"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.Term"))})), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "An either value")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "function"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Function")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A function term")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "let"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Let")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A 'let' term, which binds variables to terms")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "list"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeList (Core.TypeVariable (Core.Name "hydra.core.Term"))), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A list")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "literal"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Literal")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A literal value")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "map"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeMap (Core.MapType { - Core.mapTypeKeys = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.mapTypeValues = (Core.TypeVariable (Core.Name "hydra.core.Term"))})), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A map of keys to values")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "maybe"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeMaybe (Core.TypeVariable (Core.Name "hydra.core.Term"))), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "An optional value")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "pair"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypePair (Core.PairType { - Core.pairTypeFirst = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.pairTypeSecond = (Core.TypeVariable (Core.Name "hydra.core.Term"))})), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A pair (2-tuple)")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "record"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Record")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A record term")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "set"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeSet (Core.TypeVariable (Core.Name "hydra.core.Term"))), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A set of values")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "typeApplication"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.TypeApplicationTerm")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A System F type application term")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "typeLambda"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.TypeLambda")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A System F type abstraction term")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "union"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Injection")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "An injection; an instance of a union type")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "unit"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = Core.TypeUnit, - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A unit value; a term with no value")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "variable"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Name")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A variable reference")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "wrap"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.WrappedTerm")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A wrapped term; an instance of a wrapper type (newtype)")))])}))}]), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A data term")))])}))), - (Core.Name "hydra.core.Type", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeUnion [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "annotated"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.AnnotatedType")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "An annotated type")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "application"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.ApplicationType")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A type application")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "either"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.EitherType")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "An either (sum) type")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "forall"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.ForallType")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A universally quantified (polymorphic) type")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "function"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.FunctionType")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A function type")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "list"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A list type")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "literal"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.LiteralType")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A literal type")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "map"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.MapType")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A map type")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "maybe"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "An optional type")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "pair"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.PairType")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A pair (2-tuple) type")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "record"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeList (Core.TypeVariable (Core.Name "hydra.core.FieldType"))), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A record type")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "set"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A set type")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "union"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeList (Core.TypeVariable (Core.Name "hydra.core.FieldType"))), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A union type with field names")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "unit"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = Core.TypeUnit, - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The unit type")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "variable"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Name")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A type variable")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "void"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = Core.TypeUnit, - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The void (uninhabited, or bottom) type")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "wrap"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A wrapped type (newtype)")))])}))}]), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A data type")))])}))), - (Core.Name "hydra.core.TypeApplicationTerm", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeRecord [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "body"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The term being applied to a type")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "type"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The type argument")))])}))}]), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A term applied to a type; a type application")))])}))), - (Core.Name "hydra.core.TypeLambda", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeRecord [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "parameter"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Name")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The type variable introduced by the abstraction")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "body"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The body of the abstraction")))])}))}]), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A System F type abstraction term")))])}))), - (Core.Name "hydra.core.TypeScheme", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeRecord [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "variables"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeList (Core.TypeVariable (Core.Name "hydra.core.Name"))), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The free type variables")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "type"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The type expression")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "constraints"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeMaybe (Core.TypeMap (Core.MapType { - Core.mapTypeKeys = (Core.TypeVariable (Core.Name "hydra.core.Name")), - Core.mapTypeValues = (Core.TypeVariable (Core.Name "hydra.core.TypeVariableMetadata"))}))), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "Optional metadata for type variables, including typeclass constraints. The map keys are type variable names.")))])}))}]), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A type expression together with free type variables occurring in the expression")))])}))), - (Core.Name "hydra.core.TypeVariableMetadata", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeRecord [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "classes"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeSet (Core.TypeVariable (Core.Name "hydra.core.Name"))), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The set of typeclass constraints on this type variable")))])}))}]), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "Metadata associated with a type variable, including typeclass constraints")))])}))), - (Core.Name "hydra.core.WrappedTerm", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeRecord [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "typeName"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Name")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The name of the wrapper type")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "body"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The wrapped term")))])}))}]), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A term wrapped in a type name")))])}))), - (Core.Name "hydra.errors.DecodingError", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeWrap (Core.TypeLiteral Core.LiteralTypeString)), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "An error that occurred during decoding of a term")))])}))), - (Core.Name "hydra.errors.Error", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeUnion [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "checking"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.error.checking.CheckingError")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A type checking error")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "decoding"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "An error that occurred during decoding of a term")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "duplicateBinding"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.error.core.DuplicateBindingError")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A duplicate binding name error")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "duplicateField"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.error.core.DuplicateFieldError")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A duplicate field name error")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "other"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.errors.OtherError")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "Any other error")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "undefinedField"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.error.core.UndefinedFieldError")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A reference to an undefined field")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "undefinedTermVariable"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.error.core.UndefinedTermVariableError")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A reference to an undefined term variable")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "untypedTermVariable"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.error.core.UntypedTermVariableError")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A term variable whose type is not known")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "unexpectedTermVariant"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.error.core.UnexpectedTermVariantError")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "An unexpected term variant")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "unexpectedTypeVariant"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.error.core.UnexpectedTypeVariantError")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "An unexpected type variant")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "unification"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.errors.UnificationError")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A type unification error")))])}))}]), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "An error of any kind, with kernel errors particularly differentiated")))])}))), - (Core.Name "hydra.errors.OtherError", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeWrap (Core.TypeLiteral Core.LiteralTypeString)), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "Any other error")))])}))), - (Core.Name "hydra.errors.UnificationError", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeRecord [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "leftType"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The left-hand type in the unification")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "rightType"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The right-hand type in the unification")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "message"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeLiteral Core.LiteralTypeString), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A human-readable error message")))])}))}]), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "An error that occurred during type unification")))])}))), - (Core.Name "hydra.graph.Graph", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeRecord [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "boundTerms"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeMap (Core.MapType { - Core.mapTypeKeys = (Core.TypeVariable (Core.Name "hydra.core.Name")), - Core.mapTypeValues = (Core.TypeVariable (Core.Name "hydra.core.Term"))})), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The terms bound by all term variables in scope")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "boundTypes"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeMap (Core.MapType { - Core.mapTypeKeys = (Core.TypeVariable (Core.Name "hydra.core.Name")), - Core.mapTypeValues = (Core.TypeVariable (Core.Name "hydra.core.TypeScheme"))})), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The type schemes of all term variables in scope")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "classConstraints"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeMap (Core.MapType { - Core.mapTypeKeys = (Core.TypeVariable (Core.Name "hydra.core.Name")), - Core.mapTypeValues = (Core.TypeVariable (Core.Name "hydra.core.TypeVariableMetadata"))})), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A mutable map from type variable names to their accumulated class constraints. This is populated during type inference when operations requiring Eq or Ord are encountered.")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "lambdaVariables"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeSet (Core.TypeVariable (Core.Name "hydra.core.Name"))), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The set of term variables introduced by specifically by lambdas")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "metadata"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeMap (Core.MapType { - Core.mapTypeKeys = (Core.TypeVariable (Core.Name "hydra.core.Name")), - Core.mapTypeValues = (Core.TypeVariable (Core.Name "hydra.core.Term"))})), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "Any additional metadata bound to term variables in scope")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "primitives"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeMap (Core.MapType { - Core.mapTypeKeys = (Core.TypeVariable (Core.Name "hydra.core.Name")), - Core.mapTypeValues = (Core.TypeVariable (Core.Name "hydra.graph.Primitive"))})), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "All primitive functions and constants by name")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "schemaTypes"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeMap (Core.MapType { - Core.mapTypeKeys = (Core.TypeVariable (Core.Name "hydra.core.Name")), - Core.mapTypeValues = (Core.TypeVariable (Core.Name "hydra.core.TypeScheme"))})), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "All schema types (type schemes) in scope")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "typeVariables"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeSet (Core.TypeVariable (Core.Name "hydra.core.Name"))), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The set of type variables introduced specifically by type lambdas")))])}))}]), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A graph, or lexical environment which binds names to terms, types, primitives, and metadata")))])}))), - (Core.Name "hydra.graph.Primitive", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeRecord [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "name"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Name")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The unique name of the primitive function")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "type"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.TypeScheme")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The type signature of the primitive function")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "implementation"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.context.Context")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeList (Core.TypeVariable (Core.Name "hydra.core.Term"))), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.context.InContext")), - Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "hydra.errors.Error"))})), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.Term"))}))}))}))})), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A concrete implementation of the primitive function. The Context and Graph parameters are needed by higher-order primitives (e.g. lists.map, lists.foldl, eithers.bind) which must evaluate function arguments via term reduction; the Graph provides variable and primitive bindings, while the Context supports tracing and error reporting.")))])}))}]), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A built-in function or constant")))])}))), - (Core.Name "hydra.graph.TermCoder", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeForall (Core.ForallType { - Core.forallTypeParameter = (Core.Name "a"), - Core.forallTypeBody = (Core.TypeRecord [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "type"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The Hydra type of encoded terms")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "encode"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.context.Context")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.context.InContext")), - Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "hydra.errors.Error"))})), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "a"))}))}))}))})), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "An encode function from terms to native values")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "decode"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.context.Context")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "a")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.context.InContext")), - Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "hydra.errors.Error"))})), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.Term"))}))}))})), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A decode function from native values to terms")))])}))}])})), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A type together with a coder for mapping terms into arguments for primitive functions, and mapping computed results into terms.")))])}))), - (Core.Name "hydra.module.Definition", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeUnion [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "term"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.module.TermDefinition")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A term definition")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "type"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.module.TypeDefinition")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A type definition")))])}))}]), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A definition, which may be either a term or type definition")))])}))), - (Core.Name "hydra.module.FileExtension", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeWrap (Core.TypeLiteral Core.LiteralTypeString)), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A file extension (without the dot), e.g. \"json\" or \"py\"")))])}))), - (Core.Name "hydra.module.Library", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeRecord [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "namespace"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.module.Namespace")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A common prefix for all primitive function names in the library")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "prefix"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeLiteral Core.LiteralTypeString), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A preferred namespace prefix for function names in the library")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "primitives"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeList (Core.TypeVariable (Core.Name "hydra.graph.Primitive"))), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The primitives defined in this library")))])}))}]), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A library of primitive functions")))])}))), - (Core.Name "hydra.module.Module", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeRecord [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "namespace"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.module.Namespace")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A common prefix for all element names in the module")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "definitions"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeList (Core.TypeVariable (Core.Name "hydra.module.Definition"))), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The definitions in this module")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "termDependencies"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeList (Core.TypeVariable (Core.Name "hydra.module.Namespace"))), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "Any modules which the term expressions of this module directly depend upon")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "typeDependencies"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeList (Core.TypeVariable (Core.Name "hydra.module.Namespace"))), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "Any modules which the type expressions of this module directly depend upon")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "description"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeMaybe (Core.TypeLiteral Core.LiteralTypeString)), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "An optional human-readable description of the module")))])}))}]), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A logical collection of elements in the same namespace, having dependencies on zero or more other modules")))])}))), - (Core.Name "hydra.module.Namespace", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeWrap (Core.TypeLiteral Core.LiteralTypeString)), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A prefix for element names")))])}))), - (Core.Name "hydra.module.Namespaces", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeForall (Core.ForallType { - Core.forallTypeParameter = (Core.Name "n"), - Core.forallTypeBody = (Core.TypeRecord [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "focus"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypePair (Core.PairType { - Core.pairTypeFirst = (Core.TypeVariable (Core.Name "hydra.module.Namespace")), - Core.pairTypeSecond = (Core.TypeVariable (Core.Name "n"))})), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The namespace in focus, together with its associated value")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "mapping"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeMap (Core.MapType { - Core.mapTypeKeys = (Core.TypeVariable (Core.Name "hydra.module.Namespace")), - Core.mapTypeValues = (Core.TypeVariable (Core.Name "n"))})), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A mapping of namespaces to values")))])}))}])})), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A mapping from namespaces to values of type n, with a focus on one namespace")))])}))), - (Core.Name "hydra.module.QualifiedName", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeRecord [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "namespace"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeMaybe (Core.TypeVariable (Core.Name "hydra.module.Namespace"))), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The optional namespace")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "local"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeLiteral Core.LiteralTypeString), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The local name")))])}))}]), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A qualified name consisting of an optional namespace together with a mandatory local name")))])}))), - (Core.Name "hydra.module.TermDefinition", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeRecord [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "name"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Name")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The name of the term")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "term"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The term being defined")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "type"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeMaybe (Core.TypeVariable (Core.Name "hydra.core.TypeScheme"))), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The type scheme of the term, including any class constraints")))])}))}]), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A term-level definition, including a name, a term, and the type scheme of the term")))])}))), - (Core.Name "hydra.module.TypeDefinition", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeRecord [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "name"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Name")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The name of the type")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "type"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The type being defined")))])}))}]), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A type-level definition, including a name and the type")))])}))), - (Core.Name "hydra.util.Adapter", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeForall (Core.ForallType { - Core.forallTypeParameter = (Core.Name "t1"), - Core.forallTypeBody = (Core.TypeForall (Core.ForallType { - Core.forallTypeParameter = (Core.Name "t2"), - Core.forallTypeBody = (Core.TypeForall (Core.ForallType { - Core.forallTypeParameter = (Core.Name "v1"), - Core.forallTypeBody = (Core.TypeForall (Core.ForallType { - Core.forallTypeParameter = (Core.Name "v2"), - Core.forallTypeBody = (Core.TypeRecord [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "isLossy"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeLiteral Core.LiteralTypeBoolean), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "Whether information may be lost in the course of this adaptation")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "source"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "t1")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The source type")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "target"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "t2")), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The target type")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "coder"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.util.Coder")), - Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "v1"))})), - Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "v2"))})), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "The coder for transforming instances of the source type to instances of the target type")))])}))}])}))}))}))})), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A two-level bidirectional encoder which adapts types to types and terms to terms")))])}))), - (Core.Name "hydra.util.Bicoder", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeForall (Core.ForallType { - Core.forallTypeParameter = (Core.Name "t1"), - Core.forallTypeBody = (Core.TypeForall (Core.ForallType { - Core.forallTypeParameter = (Core.Name "t2"), - Core.forallTypeBody = (Core.TypeForall (Core.ForallType { - Core.forallTypeParameter = (Core.Name "v1"), - Core.forallTypeBody = (Core.TypeForall (Core.ForallType { - Core.forallTypeParameter = (Core.Name "v2"), - Core.forallTypeBody = (Core.TypeRecord [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "encode"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "t1")), - Core.functionTypeCodomain = (Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.util.Adapter")), - Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "t1"))})), - Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "t2"))})), - Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "v1"))})), - Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "v2"))}))})), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A function from source types to adapters")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "decode"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "t2")), - Core.functionTypeCodomain = (Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.util.Adapter")), - Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "t2"))})), - Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "t1"))})), - Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "v2"))})), - Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "v1"))}))})), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A function from target types to adapters")))])}))}])}))}))}))})), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A two-level encoder and decoder, operating both at a type level and an instance (data) level")))])}))), - (Core.Name "hydra.util.CaseConvention", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeUnion [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "camel"), - Core.fieldTypeType = Core.TypeUnit}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "pascal"), - Core.fieldTypeType = Core.TypeUnit}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "lowerSnake"), - Core.fieldTypeType = Core.TypeUnit}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "upperSnake"), - Core.fieldTypeType = Core.TypeUnit}]), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A naming convention for symbols, such as camelCase or snake_case")))])}))), - (Core.Name "hydra.util.Coder", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeForall (Core.ForallType { - Core.forallTypeParameter = (Core.Name "v1"), - Core.forallTypeBody = (Core.TypeForall (Core.ForallType { - Core.forallTypeParameter = (Core.Name "v2"), - Core.forallTypeBody = (Core.TypeRecord [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "encode"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.context.Context")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "v1")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.context.InContext")), - Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "hydra.errors.Error"))})), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "v2"))}))}))})), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A function which encodes source values as target values in a given context")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "decode"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.context.Context")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "v2")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.context.InContext")), - Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "hydra.errors.Error"))})), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "v1"))}))}))})), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "A function which decodes target values as source values in a given context")))])}))}])}))})), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "An encoder and decoder; a bidirectional transformation between two types")))])}))), - (Core.Name "hydra.util.Comparison", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeUnion [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "lessThan"), - Core.fieldTypeType = Core.TypeUnit}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "equalTo"), - Core.fieldTypeType = Core.TypeUnit}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "greaterThan"), - Core.fieldTypeType = Core.TypeUnit}]), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "An equality judgement: less than, equal to, or greater than")))])}))), - (Core.Name "hydra.util.Precision", (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeUnion [ - Core.FieldType { - Core.fieldTypeName = (Core.Name "arbitrary"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = Core.TypeUnit, - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "Arbitrary precision")))])}))}, - Core.FieldType { - Core.fieldTypeName = (Core.Name "bits"), - Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32)), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "Precision to a specified number of bits")))])}))}]), - Core.annotatedTypeAnnotation = (M.fromList [ - (Core.Name "description", (Core.TermLiteral (Core.LiteralString "Numeric precision: arbitrary precision, or precision to a specified number of bits")))])})))] diff --git a/src/gen-main/haskell/Hydra/Json/Decode.hs b/src/gen-main/haskell/Hydra/Json/Decode.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Json/Decode.hs +++ /dev/null @@ -1,260 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | JSON decoding for Hydra terms. Converts JSON Values to Terms using Either for error handling. - -module Hydra.Json.Decode where - -import qualified Hydra.Core as Core -import qualified Hydra.Json.Model as Model -import qualified Hydra.Lib.Eithers as Eithers -import qualified Hydra.Lib.Equality as Equality -import qualified Hydra.Lib.Lists as Lists -import qualified Hydra.Lib.Literals as Literals -import qualified Hydra.Lib.Logic as Logic -import qualified Hydra.Lib.Maps as Maps -import qualified Hydra.Lib.Maybes as Maybes -import qualified Hydra.Lib.Sets as Sets -import qualified Hydra.Lib.Strings as Strings -import qualified Hydra.Rewriting as Rewriting -import qualified Hydra.Show.Core as Core_ -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | Decode a JSON value to a float term. Float64/Bigfloat from numbers; Float32 from string. -decodeFloat :: Core.FloatType -> Model.Value -> Either String Core.Term -decodeFloat ft value = - case ft of - Core.FloatTypeBigfloat -> - let numResult = expectNumber value - in (Eithers.map (\n -> Core.TermLiteral (Core.LiteralFloat (Core.FloatValueBigfloat n))) numResult) - Core.FloatTypeFloat32 -> - let strResult = expectString value - in (Eithers.either (\err -> Left err) (\s -> - let parsed = Literals.readFloat32 s - in (Maybes.maybe (Left (Strings.cat [ - "invalid float32: ", - s])) (\v -> Right (Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat32 v)))) parsed)) strResult) - Core.FloatTypeFloat64 -> - let numResult = expectNumber value - in (Eithers.map (\n -> Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat64 (Literals.bigfloatToFloat64 n)))) numResult) - --- | Decode a JSON value to an integer term. Small ints from numbers; large ints from strings. -decodeInteger :: Core.IntegerType -> Model.Value -> Either String Core.Term -decodeInteger it value = - case it of - Core.IntegerTypeBigint -> - let strResult = expectString value - in (Eithers.either (\err -> Left err) (\s -> - let parsed = Literals.readBigint s - in (Maybes.maybe (Left (Strings.cat [ - "invalid bigint: ", - s])) (\v -> Right (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueBigint v)))) parsed)) strResult) - Core.IntegerTypeInt64 -> - let strResult = expectString value - in (Eithers.either (\err -> Left err) (\s -> - let parsed = Literals.readInt64 s - in (Maybes.maybe (Left (Strings.cat [ - "invalid int64: ", - s])) (\v -> Right (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt64 v)))) parsed)) strResult) - Core.IntegerTypeUint32 -> - let strResult = expectString value - in (Eithers.either (\err -> Left err) (\s -> - let parsed = Literals.readUint32 s - in (Maybes.maybe (Left (Strings.cat [ - "invalid uint32: ", - s])) (\v -> Right (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueUint32 v)))) parsed)) strResult) - Core.IntegerTypeUint64 -> - let strResult = expectString value - in (Eithers.either (\err -> Left err) (\s -> - let parsed = Literals.readUint64 s - in (Maybes.maybe (Left (Strings.cat [ - "invalid uint64: ", - s])) (\v -> Right (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueUint64 v)))) parsed)) strResult) - Core.IntegerTypeInt8 -> - let numResult = expectNumber value - in (Eithers.map (\n -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt8 (Literals.bigintToInt8 (Literals.bigfloatToBigint n))))) numResult) - Core.IntegerTypeInt16 -> - let numResult = expectNumber value - in (Eithers.map (\n -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt16 (Literals.bigintToInt16 (Literals.bigfloatToBigint n))))) numResult) - Core.IntegerTypeInt32 -> - let numResult = expectNumber value - in (Eithers.map (\n -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 (Literals.bigintToInt32 (Literals.bigfloatToBigint n))))) numResult) - Core.IntegerTypeUint8 -> - let numResult = expectNumber value - in (Eithers.map (\n -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueUint8 (Literals.bigintToUint8 (Literals.bigfloatToBigint n))))) numResult) - Core.IntegerTypeUint16 -> - let numResult = expectNumber value - in (Eithers.map (\n -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueUint16 (Literals.bigintToUint16 (Literals.bigfloatToBigint n))))) numResult) - --- | Decode a JSON value to a literal term -decodeLiteral :: Core.LiteralType -> Model.Value -> Either String Core.Term -decodeLiteral lt value = - case lt of - Core.LiteralTypeBinary -> - let strResult = expectString value - in (Eithers.map (\s -> Core.TermLiteral (Core.LiteralBinary (Literals.stringToBinary s))) strResult) - Core.LiteralTypeBoolean -> case value of - Model.ValueBoolean v1 -> Right (Core.TermLiteral (Core.LiteralBoolean v1)) - _ -> Left "expected boolean" - Core.LiteralTypeFloat v0 -> decodeFloat v0 value - Core.LiteralTypeInteger v0 -> decodeInteger v0 value - Core.LiteralTypeString -> - let strResult = expectString value - in (Eithers.map (\s -> Core.TermLiteral (Core.LiteralString s)) strResult) - --- | Extract an array from a JSON value -expectArray :: Model.Value -> Either String [Model.Value] -expectArray value = - case value of - Model.ValueArray v0 -> Right v0 - _ -> Left "expected array" - --- | Extract a number from a JSON value -expectNumber :: Model.Value -> Either String Double -expectNumber value = - case value of - Model.ValueNumber v0 -> Right v0 - _ -> Left "expected number" - --- | Extract an object from a JSON value -expectObject :: Model.Value -> Either String (M.Map String Model.Value) -expectObject value = - case value of - Model.ValueObject v0 -> Right v0 - _ -> Left "expected object" - --- | Extract a string from a JSON value -expectString :: Model.Value -> Either String String -expectString value = - case value of - Model.ValueString v0 -> Right v0 - _ -> Left "expected string" - --- | Decode a JSON value to a Hydra term given a type and type name. Returns Left for type mismatches. -fromJson :: M.Map Core.Name Core.Type -> Core.Name -> Core.Type -> Model.Value -> Either String Core.Term -fromJson types tname typ value = - - let stripped = Rewriting.deannotateType typ - in case stripped of - Core.TypeLiteral v0 -> decodeLiteral v0 value - Core.TypeList v0 -> - let decodeElem = \v -> fromJson types tname v0 v - arrResult = expectArray value - in (Eithers.either (\err -> Left err) (\arr -> - let decoded = Eithers.mapList decodeElem arr - in (Eithers.map (\ts -> Core.TermList ts) decoded)) arrResult) - Core.TypeSet v0 -> - let decodeElem = \v -> fromJson types tname v0 v - arrResult = expectArray value - in (Eithers.either (\err -> Left err) (\arr -> - let decoded = Eithers.mapList decodeElem arr - in (Eithers.map (\elems -> Core.TermSet (Sets.fromList elems)) decoded)) arrResult) - Core.TypeMaybe v0 -> - let decodeJust = \arr -> Eithers.map (\v -> Core.TermMaybe (Just v)) (fromJson types tname v0 (Lists.head arr)) - decodeMaybeArray = - \arr -> - let len = Lists.length arr - in (Logic.ifElse (Equality.equal len 0) (Right (Core.TermMaybe Nothing)) (Logic.ifElse (Equality.equal len 1) (decodeJust arr) (Left "expected single-element array for Just"))) - in case value of - Model.ValueNull -> Right (Core.TermMaybe Nothing) - Model.ValueArray v1 -> decodeMaybeArray v1 - _ -> Left "expected null or single-element array for Maybe" - Core.TypeRecord v0 -> - let objResult = expectObject value - in (Eithers.either (\err -> Left err) (\obj -> - let decodeField = - \ft -> - let fname = Core.fieldTypeName ft - ftype = Core.fieldTypeType ft - mval = Maps.lookup (Core.unName fname) obj - defaultVal = Model.ValueNull - jsonVal = Maybes.fromMaybe defaultVal mval - decoded = fromJson types tname ftype jsonVal - in (Eithers.map (\v -> Core.Field { - Core.fieldName = fname, - Core.fieldTerm = v}) decoded) - decodedFields = Eithers.mapList decodeField v0 - in (Eithers.map (\fs -> Core.TermRecord (Core.Record { - Core.recordTypeName = tname, - Core.recordFields = fs})) decodedFields)) objResult) - Core.TypeUnion v0 -> - let decodeVariant = - \key -> \val -> \ftype -> - let jsonVal = Maybes.fromMaybe Model.ValueNull val - decoded = fromJson types tname ftype jsonVal - in (Eithers.map (\v -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = tname, - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name key), - Core.fieldTerm = v}})) decoded) - tryField = - \key -> \val -> \ft -> Logic.ifElse (Equality.equal (Core.unName (Core.fieldTypeName ft)) key) (Just (decodeVariant key val (Core.fieldTypeType ft))) Nothing - findAndDecode = - \key -> \val -> \fts -> Logic.ifElse (Lists.null fts) (Left (Strings.cat [ - "unknown variant: ", - key])) (Maybes.maybe (findAndDecode key val (Lists.tail fts)) (\r -> r) (tryField key val (Lists.head fts))) - decodeSingleKey = \obj -> findAndDecode (Lists.head (Maps.keys obj)) (Maps.lookup (Lists.head (Maps.keys obj)) obj) v0 - processUnion = - \obj -> Logic.ifElse (Equality.equal (Lists.length (Maps.keys obj)) 1) (decodeSingleKey obj) (Left "expected single-key object for union") - objResult = expectObject value - in (Eithers.either (\err -> Left err) (\obj -> processUnion obj) objResult) - Core.TypeUnit -> - let objResult = expectObject value - in (Eithers.map (\_ -> Core.TermUnit) objResult) - Core.TypeWrap v0 -> - let decoded = fromJson types tname v0 value - in (Eithers.map (\v -> Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = tname, - Core.wrappedTermBody = v})) decoded) - Core.TypeMap v0 -> - let keyType = Core.mapTypeKeys v0 - valType = Core.mapTypeValues v0 - arrResult = expectArray value - in (Eithers.either (\err -> Left err) (\arr -> - let decodeEntry = - \entryJson -> - let objResult = expectObject entryJson - in (Eithers.either (\err -> Left err) (\entryObj -> - let keyJson = Maps.lookup "@key" entryObj - valJson = Maps.lookup "@value" entryObj - in (Maybes.maybe (Left "missing @key in map entry") (\kj -> Maybes.maybe (Left "missing @value in map entry") (\vj -> - let decodedKey = fromJson types tname keyType kj - decodedVal = fromJson types tname valType vj - in (Eithers.either (\err -> Left err) (\k -> Eithers.map (\v -> (k, v)) decodedVal) decodedKey)) valJson) keyJson)) objResult) - entries = Eithers.mapList decodeEntry arr - in (Eithers.map (\es -> Core.TermMap (Maps.fromList es)) entries)) arrResult) - Core.TypePair v0 -> - let firstType = Core.pairTypeFirst v0 - secondType = Core.pairTypeSecond v0 - objResult = expectObject value - in (Eithers.either (\err -> Left err) (\obj -> - let firstJson = Maps.lookup "@first" obj - secondJson = Maps.lookup "@second" obj - in (Maybes.maybe (Left "missing @first in pair") (\fj -> Maybes.maybe (Left "missing @second in pair") (\sj -> - let decodedFirst = fromJson types tname firstType fj - decodedSecond = fromJson types tname secondType sj - in (Eithers.either (\err -> Left err) (\f -> Eithers.map (\s -> Core.TermPair (f, s)) decodedSecond) decodedFirst)) secondJson) firstJson)) objResult) - Core.TypeEither v0 -> - let leftType = Core.eitherTypeLeft v0 - rightType = Core.eitherTypeRight v0 - objResult = expectObject value - in (Eithers.either (\err -> Left err) (\obj -> - let leftJson = Maps.lookup "@left" obj - rightJson = Maps.lookup "@right" obj - in (Maybes.maybe (Maybes.maybe (Left "expected @left or @right in Either") (\rj -> - let decoded = fromJson types tname rightType rj - in (Eithers.map (\v -> Core.TermEither (Right v)) decoded)) rightJson) (\lj -> - let decoded = fromJson types tname leftType lj - in (Eithers.map (\v -> Core.TermEither (Left v)) decoded)) leftJson)) objResult) - Core.TypeVariable v0 -> - let lookedUp = Maps.lookup v0 types - in (Maybes.maybe (Left (Strings.cat [ - "unknown type variable: ", - (Core.unName v0)])) (\resolvedType -> fromJson types v0 resolvedType value) lookedUp) - _ -> Left (Strings.cat [ - "unsupported type for JSON decoding: ", - (Core_.type_ typ)]) diff --git a/src/gen-main/haskell/Hydra/Json/Encode.hs b/src/gen-main/haskell/Hydra/Json/Encode.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Json/Encode.hs +++ /dev/null @@ -1,123 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | JSON encoding for Hydra terms. Converts Terms to JSON Values using Either for error handling. - -module Hydra.Json.Encode where - -import qualified Hydra.Core as Core -import qualified Hydra.Json.Model as Model -import qualified Hydra.Lib.Eithers as Eithers -import qualified Hydra.Lib.Literals as Literals -import qualified Hydra.Lib.Maps as Maps -import qualified Hydra.Lib.Maybes as Maybes -import qualified Hydra.Lib.Pairs as Pairs -import qualified Hydra.Lib.Sets as Sets -import qualified Hydra.Lib.Strings as Strings -import qualified Hydra.Rewriting as Rewriting -import qualified Hydra.Show.Core as Core_ -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | Encode a float value to JSON. Float64/Bigfloat use native numbers; Float32 uses string. -encodeFloat :: Core.FloatValue -> Either t0 Model.Value -encodeFloat fv = - case fv of - Core.FloatValueBigfloat v0 -> Right (Model.ValueNumber v0) - Core.FloatValueFloat32 v0 -> Right (Model.ValueString (Literals.showFloat32 v0)) - Core.FloatValueFloat64 v0 -> Right (Model.ValueNumber (Literals.float64ToBigfloat v0)) - --- | Encode an integer value to JSON. Small ints use native numbers; large ints use strings. -encodeInteger :: Core.IntegerValue -> Either t0 Model.Value -encodeInteger iv = - case iv of - Core.IntegerValueBigint v0 -> Right (Model.ValueString (Literals.showBigint v0)) - Core.IntegerValueInt64 v0 -> Right (Model.ValueString (Literals.showInt64 v0)) - Core.IntegerValueUint32 v0 -> Right (Model.ValueString (Literals.showUint32 v0)) - Core.IntegerValueUint64 v0 -> Right (Model.ValueString (Literals.showUint64 v0)) - Core.IntegerValueInt8 v0 -> Right (Model.ValueNumber (Literals.bigintToBigfloat (Literals.int8ToBigint v0))) - Core.IntegerValueInt16 v0 -> Right (Model.ValueNumber (Literals.bigintToBigfloat (Literals.int16ToBigint v0))) - Core.IntegerValueInt32 v0 -> Right (Model.ValueNumber (Literals.bigintToBigfloat (Literals.int32ToBigint v0))) - Core.IntegerValueUint8 v0 -> Right (Model.ValueNumber (Literals.bigintToBigfloat (Literals.uint8ToBigint v0))) - Core.IntegerValueUint16 v0 -> Right (Model.ValueNumber (Literals.bigintToBigfloat (Literals.uint16ToBigint v0))) - --- | Encode a Hydra literal to a JSON value -encodeLiteral :: Core.Literal -> Either t0 Model.Value -encodeLiteral lit = - case lit of - Core.LiteralBinary v0 -> Right (Model.ValueString (Literals.binaryToString v0)) - Core.LiteralBoolean v0 -> Right (Model.ValueBoolean v0) - Core.LiteralFloat v0 -> encodeFloat v0 - Core.LiteralInteger v0 -> encodeInteger v0 - Core.LiteralString v0 -> Right (Model.ValueString v0) - --- | Encode a Hydra term to a JSON value. Returns Left for unsupported constructs. -toJson :: Core.Term -> Either String Model.Value -toJson term = - - let stripped = Rewriting.deannotateTerm term - in case stripped of - Core.TermLiteral v0 -> encodeLiteral v0 - Core.TermList v0 -> - let results = Eithers.mapList (\t -> toJson t) v0 - in (Eithers.map (\vs -> Model.ValueArray vs) results) - Core.TermSet v0 -> - let terms = Sets.toList v0 - results = Eithers.mapList (\t -> toJson t) terms - in (Eithers.map (\vs -> Model.ValueArray vs) results) - Core.TermMaybe v0 -> Maybes.maybe (Right Model.ValueNull) (\v -> - let encodedMaybe = toJson v - in (Eithers.map (\encoded -> Model.ValueArray [ - encoded]) encodedMaybe)) v0 - Core.TermRecord v0 -> - let encodeField = - \f -> - let fname = Core.unName (Core.fieldName f) - fterm = Core.fieldTerm f - encodedField = toJson fterm - in (Eithers.map (\v -> (fname, v)) encodedField) - fields = Core.recordFields v0 - encodedFields = Eithers.mapList encodeField fields - in (Eithers.map (\fs -> Model.ValueObject (Maps.fromList fs)) encodedFields) - Core.TermUnion v0 -> - let field = Core.injectionField v0 - fname = Core.unName (Core.fieldName field) - fterm = Core.fieldTerm field - encodedUnion = toJson fterm - in (Eithers.map (\v -> Model.ValueObject (Maps.fromList [ - (fname, v)])) encodedUnion) - Core.TermUnit -> Right (Model.ValueObject Maps.empty) - Core.TermWrap v0 -> toJson (Core.wrappedTermBody v0) - Core.TermMap v0 -> - let encodeEntry = - \kv -> - let k = Pairs.first kv - v = Pairs.second kv - encodedK = toJson k - encodedV = toJson v - in (Eithers.either (\err -> Left err) (\ek -> Eithers.map (\ev -> Model.ValueObject (Maps.fromList [ - ("@key", ek), - ("@value", ev)])) encodedV) encodedK) - entries = Eithers.mapList encodeEntry (Maps.toList v0) - in (Eithers.map (\es -> Model.ValueArray es) entries) - Core.TermPair v0 -> - let first = Pairs.first v0 - second = Pairs.second v0 - encodedFirst = toJson first - encodedSecond = toJson second - in (Eithers.either (\err -> Left err) (\ef -> Eithers.map (\es -> Model.ValueObject (Maps.fromList [ - ("@first", ef), - ("@second", es)])) encodedSecond) encodedFirst) - Core.TermEither v0 -> Eithers.either (\l -> - let encodedL = toJson l - in (Eithers.map (\v -> Model.ValueObject (Maps.fromList [ - ("@left", v)])) encodedL)) (\r -> - let encodedR = toJson r - in (Eithers.map (\v -> Model.ValueObject (Maps.fromList [ - ("@right", v)])) encodedR)) v0 - _ -> Left (Strings.cat [ - "unsupported term variant for JSON encoding: ", - (Core_.term term)]) diff --git a/src/gen-main/haskell/Hydra/Json/Model.hs b/src/gen-main/haskell/Hydra/Json/Model.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Json/Model.hs +++ /dev/null @@ -1,43 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | A JSON syntax model. See the BNF at https://www.json.org - -module Hydra.Json.Model where - -import qualified Hydra.Core as Core -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | A JSON value -data Value = - -- | A JSON array - ValueArray [Value] | - -- | A boolean value - ValueBoolean Bool | - -- | JSON's null value - ValueNull | - -- | A numeric value - ValueNumber Double | - -- | A JSON object as a set of key/value pairs - ValueObject (M.Map String Value) | - -- | A string value - ValueString String - deriving (Eq, Ord, Read, Show) - -_Value = Core.Name "hydra.json.model.Value" - -_Value_array = Core.Name "array" - -_Value_boolean = Core.Name "boolean" - -_Value_null = Core.Name "null" - -_Value_number = Core.Name "number" - -_Value_object = Core.Name "object" - -_Value_string = Core.Name "string" diff --git a/src/gen-main/haskell/Hydra/Json/Parser.hs b/src/gen-main/haskell/Hydra/Json/Parser.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Json/Parser.hs +++ /dev/null @@ -1,128 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | JSON parser using Hydra parser combinators - -module Hydra.Json.Parser where - -import qualified Hydra.Json.Model as Model -import qualified Hydra.Lib.Equality as Equality -import qualified Hydra.Lib.Lists as Lists -import qualified Hydra.Lib.Literals as Literals -import qualified Hydra.Lib.Logic as Logic -import qualified Hydra.Lib.Maps as Maps -import qualified Hydra.Lib.Maybes as Maybes -import qualified Hydra.Lib.Strings as Strings -import qualified Hydra.Parsers as Parsers -import qualified Hydra.Parsing as Parsing -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | Parse a single digit (0-9) -digit :: Parsing.Parser Int -digit = Parsers.satisfy (\c -> Logic.and (Equality.gte c 48) (Equality.lte c 57)) - --- | Parse one or more digits as a string -digits :: Parsing.Parser String -digits = Parsers.map Strings.fromList (Parsers.some digit) - --- | Parse a JSON array -jsonArray :: Parsing.Parser Model.Value -jsonArray = - Parsers.map (\x -> Model.ValueArray x) (Parsers.between (token (Parsers.char 91)) (token (Parsers.char 93)) (Parsers.sepBy (Parsers.lazy (\_ -> jsonValue)) (token (Parsers.char 44)))) - --- | Parse JSON boolean (true or false) -jsonBool :: Parsing.Parser Model.Value -jsonBool = - Parsers.alt (Parsers.map (\_ -> Model.ValueBoolean True) (token (Parsers.string "true"))) (Parsers.map (\_ -> Model.ValueBoolean False) (token (Parsers.string "false"))) - --- | Parse a JSON escape sequence after the backslash -jsonEscapeChar :: Parsing.Parser Int -jsonEscapeChar = - Parsers.choice [ - Parsers.map (\_ -> 34) (Parsers.char 34), - (Parsers.map (\_ -> 92) (Parsers.char 92)), - (Parsers.map (\_ -> 47) (Parsers.char 47)), - (Parsers.map (\_ -> 8) (Parsers.char 98)), - (Parsers.map (\_ -> 12) (Parsers.char 102)), - (Parsers.map (\_ -> 10) (Parsers.char 110)), - (Parsers.map (\_ -> 13) (Parsers.char 114)), - (Parsers.map (\_ -> 9) (Parsers.char 116))] - --- | Parse the optional exponent part of a JSON number -jsonExponentPart :: Parsing.Parser (Maybe String) -jsonExponentPart = - Parsers.optional (Parsers.bind (Parsers.satisfy (\c -> Logic.or (Equality.equal c 101) (Equality.equal c 69))) (\_ -> Parsers.bind (Parsers.optional (Parsers.satisfy (\c -> Logic.or (Equality.equal c 43) (Equality.equal c 45)))) (\sign -> Parsers.map (\digits -> Strings.cat2 (Strings.cat2 "e" (Maybes.maybe "" (\arg_ -> Strings.fromList (Lists.pure arg_)) sign)) digits) digits))) - --- | Parse the optional fractional part of a JSON number -jsonFractionPart :: Parsing.Parser (Maybe String) -jsonFractionPart = Parsers.optional (Parsers.bind (Parsers.char 46) (\_ -> Parsers.map (\d -> Strings.cat2 "." d) digits)) - --- | Parse the integer part of a JSON number (optional minus, then digits) -jsonIntegerPart :: Parsing.Parser String -jsonIntegerPart = - Parsers.bind (Parsers.optional (Parsers.char 45)) (\sign -> Parsers.bind digits (\digits -> Parsers.pure (Maybes.maybe digits (\_ -> Strings.cat2 "-" digits) sign))) - --- | Parse a JSON object key-value pair -jsonKeyValue :: Parsing.Parser (String, Model.Value) -jsonKeyValue = - Parsers.bind (token (Parsers.bind (Parsers.char 34) (\_ -> Parsers.bind (Parsers.many jsonStringChar) (\chars -> Parsers.bind (Parsers.char 34) (\_ -> Parsers.pure (Strings.fromList chars)))))) (\key -> Parsers.bind (token (Parsers.char 58)) (\_ -> Parsers.map (\v -> (key, v)) (Parsers.lazy (\_ -> jsonValue)))) - --- | Parse JSON null value -jsonNull :: Parsing.Parser Model.Value -jsonNull = Parsers.map (\_ -> Model.ValueNull) (token (Parsers.string "null")) - --- | Parse a JSON number (integer, decimal, or scientific notation) -jsonNumber :: Parsing.Parser Model.Value -jsonNumber = - token (Parsers.bind jsonIntegerPart (\intPart -> Parsers.bind jsonFractionPart (\fracPart -> Parsers.bind jsonExponentPart (\expPart -> - let numStr = - Strings.cat2 (Strings.cat2 intPart (Maybes.maybe "" Equality.identity fracPart)) (Maybes.maybe "" Equality.identity expPart) - in (Parsers.pure (Model.ValueNumber (Maybes.maybe 0.0 Equality.identity (Literals.readBigfloat numStr)))))))) - --- | Parse a JSON object -jsonObject :: Parsing.Parser Model.Value -jsonObject = - Parsers.map (\arg_ -> (\x -> Model.ValueObject x) (Maps.fromList arg_)) (Parsers.between (token (Parsers.char 123)) (token (Parsers.char 125)) (Parsers.sepBy jsonKeyValue (token (Parsers.char 44)))) - --- | Parse a JSON string value -jsonString :: Parsing.Parser Model.Value -jsonString = - token (Parsers.bind (Parsers.char 34) (\_ -> Parsers.bind (Parsers.many jsonStringChar) (\chars -> Parsers.bind (Parsers.char 34) (\_ -> Parsers.pure (Model.ValueString (Strings.fromList chars)))))) - --- | Parse a single character in a JSON string (handling escapes) -jsonStringChar :: Parsing.Parser Int -jsonStringChar = - Parsers.alt (Parsers.bind (Parsers.char 92) (\_ -> jsonEscapeChar)) (Parsers.satisfy (\c -> Logic.and (Logic.not (Equality.equal c 34)) (Logic.not (Equality.equal c 92)))) - --- | Parse any JSON value -jsonValue :: Parsing.Parser Model.Value -jsonValue = - Parsers.choice [ - jsonNull, - jsonBool, - jsonNumber, - jsonString, - jsonArray, - jsonObject] - --- | Parse a JSON document from a string -parseJson :: String -> Parsing.ParseResult Model.Value -parseJson input = - Parsing.unParser (Parsers.bind whitespace (\_ -> Parsers.bind jsonValue (\v -> Parsers.bind whitespace (\_ -> Parsers.bind Parsers.eof (\_ -> Parsers.pure v))))) input - --- | Parse a token followed by optional whitespace -token :: Parsing.Parser t0 -> Parsing.Parser t0 -token p = Parsers.bind p (\x -> Parsers.bind whitespace (\_ -> Parsers.pure x)) - --- | Parse zero or more JSON whitespace characters (space, tab, newline, carriage return) -whitespace :: Parsing.Parser () -whitespace = - Parsers.map (\_ -> ()) (Parsers.many (Parsers.satisfy (\c -> Lists.foldl Logic.or False [ - Equality.equal c 32, - (Equality.equal c 9), - (Equality.equal c 10), - (Equality.equal c 13)]))) diff --git a/src/gen-main/haskell/Hydra/Json/Writer.hs b/src/gen-main/haskell/Hydra/Json/Writer.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Json/Writer.hs +++ /dev/null @@ -1,73 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | JSON serialization functions using the Hydra AST - -module Hydra.Json.Writer where - -import qualified Hydra.Ast as Ast -import qualified Hydra.Json.Model as Model -import qualified Hydra.Lib.Equality as Equality -import qualified Hydra.Lib.Lists as Lists -import qualified Hydra.Lib.Literals as Literals -import qualified Hydra.Lib.Logic as Logic -import qualified Hydra.Lib.Maps as Maps -import qualified Hydra.Lib.Math as Math -import qualified Hydra.Lib.Pairs as Pairs -import qualified Hydra.Lib.Strings as Strings -import qualified Hydra.Serialization as Serialization -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | The colon operator used to separate keys and values in JSON objects -colonOp :: Ast.Op -colonOp = - Ast.Op { - Ast.opSymbol = (Ast.Symbol ":"), - Ast.opPadding = Ast.Padding { - Ast.paddingLeft = Ast.WsNone, - Ast.paddingRight = Ast.WsSpace}, - Ast.opPrecedence = (Ast.Precedence 0), - Ast.opAssociativity = Ast.AssociativityNone} - --- | Escape and quote a string for JSON output -jsonString :: String -> String -jsonString s = - - let hexEscape = - \c -> - let hi = Strings.fromList (Lists.pure (Strings.charAt (Math.div c 16) "0123456789abcdef")) - lo = Strings.fromList (Lists.pure (Strings.charAt (Math.mod c 16) "0123456789abcdef")) - in (Strings.cat2 (Strings.cat2 "\\u00" hi) lo) - escape = - \c -> Logic.ifElse (Equality.equal c 34) "\\\"" (Logic.ifElse (Equality.equal c 92) "\\\\" (Logic.ifElse (Equality.equal c 8) "\\b" (Logic.ifElse (Equality.equal c 12) "\\f" (Logic.ifElse (Equality.equal c 10) "\\n" (Logic.ifElse (Equality.equal c 13) "\\r" (Logic.ifElse (Equality.equal c 9) "\\t" (Logic.ifElse (Equality.lt c 32) (hexEscape c) (Strings.fromList (Lists.pure c))))))))) - escaped = Strings.cat (Lists.map escape (Strings.toList s)) - in (Strings.cat2 (Strings.cat2 "\"" escaped) "\"") - --- | Convert a key-value pair to an AST expression -keyValueToExpr :: (String, Model.Value) -> Ast.Expr -keyValueToExpr pair = - - let key = Pairs.first pair - value = Pairs.second pair - in (Serialization.ifx colonOp (Serialization.cst (jsonString key)) (valueToExpr value)) - --- | Serialize a JSON value to a string -printJson :: Model.Value -> String -printJson value = Serialization.printExpr (valueToExpr value) - --- | Convert a JSON value to an AST expression for serialization -valueToExpr :: Model.Value -> Ast.Expr -valueToExpr value = - case value of - Model.ValueArray v0 -> Serialization.bracketListAdaptive (Lists.map valueToExpr v0) - Model.ValueBoolean v0 -> Serialization.cst (Logic.ifElse v0 "true" "false") - Model.ValueNull -> Serialization.cst "null" - Model.ValueNumber v0 -> - let rounded = Literals.bigfloatToBigint v0 - in (Serialization.cst (Logic.ifElse (Equality.equal v0 (Literals.bigintToBigfloat rounded)) (Literals.showBigint rounded) (Literals.showBigfloat v0))) - Model.ValueObject v0 -> Serialization.bracesListAdaptive (Lists.map keyValueToExpr (Maps.toList v0)) - Model.ValueString v0 -> Serialization.cst (jsonString v0) diff --git a/src/gen-main/haskell/Hydra/Json/Yaml/Decode.hs b/src/gen-main/haskell/Hydra/Json/Yaml/Decode.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Json/Yaml/Decode.hs +++ /dev/null @@ -1,57 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | YAML-to-JSON decoding. Converts YAML Nodes to JSON Values (may fail for non-JSON YAML), and YAML Nodes to Hydra Terms via JSON. - -module Hydra.Json.Yaml.Decode where - -import qualified Hydra.Core as Core -import qualified Hydra.Ext.Org.Yaml.Model as Model -import qualified Hydra.Json.Decode as Decode -import qualified Hydra.Json.Model as Model_ -import qualified Hydra.Lib.Eithers as Eithers -import qualified Hydra.Lib.Literals as Literals -import qualified Hydra.Lib.Maps as Maps -import qualified Hydra.Lib.Pairs as Pairs -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | Decode a YAML node to a Hydra term via JSON decoding. -fromYaml :: M.Map Core.Name Core.Type -> Core.Name -> Core.Type -> Model.Node -> Either String Core.Term -fromYaml types tname typ node = - - let jsonResult = yamlToJson node - in (Eithers.either (\err -> Left err) (\json -> Decode.fromJson types tname typ json) jsonResult) - --- | Convert a YAML node to a JSON value. Fails for non-JSON YAML features (e.g. non-string mapping keys). -yamlToJson :: Model.Node -> Either String Model_.Value -yamlToJson node = - case node of - Model.NodeMapping v0 -> - let convertEntry = - \kv -> - let keyNode = Pairs.first kv - valNode = Pairs.second kv - keyResult = - case keyNode of - Model.NodeScalar v1 -> case v1 of - Model.ScalarStr v2 -> Right v2 - _ -> Left "non-string YAML mapping key" - _ -> Left "non-scalar YAML mapping key" - in (Eithers.either (\err -> Left err) (\key -> - let valResult = yamlToJson valNode - in (Eithers.map (\v -> (key, v)) valResult)) keyResult) - entries = Eithers.mapList convertEntry (Maps.toList v0) - in (Eithers.map (\es -> Model_.ValueObject (Maps.fromList es)) entries) - Model.NodeScalar v0 -> case v0 of - Model.ScalarBool v1 -> Right (Model_.ValueBoolean v1) - Model.ScalarFloat v1 -> Right (Model_.ValueNumber v1) - Model.ScalarInt v1 -> Right (Model_.ValueNumber (Literals.bigintToBigfloat v1)) - Model.ScalarNull -> Right Model_.ValueNull - Model.ScalarStr v1 -> Right (Model_.ValueString v1) - Model.NodeSequence v0 -> - let results = Eithers.mapList (\n -> yamlToJson n) v0 - in (Eithers.map (\vs -> Model_.ValueArray vs) results) diff --git a/src/gen-main/haskell/Hydra/Json/Yaml/Encode.hs b/src/gen-main/haskell/Hydra/Json/Yaml/Encode.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Json/Yaml/Encode.hs +++ /dev/null @@ -1,35 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | JSON-to-YAML encoding. Converts JSON Values to YAML Nodes (always succeeds), and Hydra Terms to YAML Nodes via JSON. - -module Hydra.Json.Yaml.Encode where - -import qualified Hydra.Core as Core -import qualified Hydra.Ext.Org.Yaml.Model as Model -import qualified Hydra.Json.Encode as Encode -import qualified Hydra.Json.Model as Model_ -import qualified Hydra.Lib.Eithers as Eithers -import qualified Hydra.Lib.Lists as Lists -import qualified Hydra.Lib.Maps as Maps -import qualified Hydra.Lib.Pairs as Pairs -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | Convert a JSON value to a YAML node. Always succeeds since YAML is a superset of JSON. -jsonToYaml :: Model_.Value -> Model.Node -jsonToYaml value = - case value of - Model_.ValueArray v0 -> Model.NodeSequence (Lists.map (\v -> jsonToYaml v) v0) - Model_.ValueBoolean v0 -> Model.NodeScalar (Model.ScalarBool v0) - Model_.ValueNull -> Model.NodeScalar Model.ScalarNull - Model_.ValueNumber v0 -> Model.NodeScalar (Model.ScalarFloat v0) - Model_.ValueObject v0 -> Model.NodeMapping (Maps.fromList (Lists.map (\kv -> (Model.NodeScalar (Model.ScalarStr (Pairs.first kv)), (jsonToYaml (Pairs.second kv)))) (Maps.toList v0))) - Model_.ValueString v0 -> Model.NodeScalar (Model.ScalarStr v0) - --- | Encode a Hydra term to a YAML node via JSON encoding. -toYaml :: Core.Term -> Either String Model.Node -toYaml term = Eithers.map (\v -> jsonToYaml v) (Encode.toJson term) diff --git a/src/gen-main/haskell/Hydra/Languages.hs b/src/gen-main/haskell/Hydra/Languages.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Languages.hs +++ /dev/null @@ -1,42 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Language constraints for Hydra Core - -module Hydra.Languages where - -import qualified Hydra.Coders as Coders -import qualified Hydra.Core as Core -import qualified Hydra.Lib.Sets as Sets -import qualified Hydra.Reflect as Reflect -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | Language constraints for Hydra Core, i.e. no constraints. -hydraLanguage :: Coders.Language -hydraLanguage = - Coders.Language { - Coders.languageName = (Coders.LanguageName "hydra.core"), - Coders.languageConstraints = Coders.LanguageConstraints { - Coders.languageConstraintsEliminationVariants = eliminationVariants, - Coders.languageConstraintsLiteralVariants = literalVariants, - Coders.languageConstraintsFloatTypes = floatTypes, - Coders.languageConstraintsFunctionVariants = functionVariants, - Coders.languageConstraintsIntegerTypes = integerTypes, - Coders.languageConstraintsTermVariants = termVariants, - Coders.languageConstraintsTypeVariants = typeVariants, - Coders.languageConstraintsTypes = types}} - where - eliminationVariants = Sets.fromList Reflect.eliminationVariants - literalVariants = Sets.fromList Reflect.literalVariants - floatTypes = Sets.fromList Reflect.floatTypes - functionVariants = Sets.fromList Reflect.functionVariants - integerTypes = Sets.fromList Reflect.integerTypes - termVariants = Sets.fromList Reflect.termVariants - typeVariants = Sets.fromList Reflect.typeVariants - types = - \t -> case t of - _ -> True diff --git a/src/gen-main/haskell/Hydra/Lexical.hs b/src/gen-main/haskell/Hydra/Lexical.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Lexical.hs +++ /dev/null @@ -1,274 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | A module for lexical operations over graphs. - -module Hydra.Lexical where - -import qualified Hydra.Context as Context -import qualified Hydra.Core as Core -import qualified Hydra.Errors as Errors -import qualified Hydra.Graph as Graph -import qualified Hydra.Lib.Eithers as Eithers -import qualified Hydra.Lib.Equality as Equality -import qualified Hydra.Lib.Lists as Lists -import qualified Hydra.Lib.Literals as Literals -import qualified Hydra.Lib.Logic as Logic -import qualified Hydra.Lib.Maps as Maps -import qualified Hydra.Lib.Math as Math -import qualified Hydra.Lib.Maybes as Maybes -import qualified Hydra.Lib.Pairs as Pairs -import qualified Hydra.Lib.Sets as Sets -import qualified Hydra.Lib.Strings as Strings -import qualified Hydra.Rewriting as Rewriting -import qualified Hydra.Show.Core as Core_ -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | Build a Graph from element bindings, environment, and primitives -buildGraph :: [Core.Binding] -> M.Map Core.Name (Maybe Core.Term) -> M.Map Core.Name Graph.Primitive -> Graph.Graph -buildGraph elements environment primitives = - - let elementTerms = Maps.fromList (Lists.map (\b -> (Core.bindingName b, (Core.bindingTerm b))) elements) - letTerms = Maps.map (\mt -> Maybes.fromJust mt) (Maps.filter (\mt -> Maybes.isJust mt) environment) - elementTypes = - Maps.fromList (Maybes.cat (Lists.map (\b -> Maybes.map (\ts -> (Core.bindingName b, ts)) (Core.bindingType b)) elements)) - in Graph.Graph { - Graph.graphBoundTerms = (Maps.union elementTerms letTerms), - Graph.graphBoundTypes = elementTypes, - Graph.graphClassConstraints = Maps.empty, - Graph.graphLambdaVariables = (Sets.fromList (Maps.keys (Maps.filter (\mt -> Maybes.isNothing mt) environment))), - Graph.graphMetadata = Maps.empty, - Graph.graphPrimitives = primitives, - Graph.graphSchemaTypes = Maps.empty, - Graph.graphTypeVariables = Sets.empty} - -chooseUniqueName :: S.Set Core.Name -> Core.Name -> Core.Name -chooseUniqueName reserved name = - - let tryName = - \index -> - let candidate = Logic.ifElse (Equality.equal index 1) name (Core.Name (Strings.cat2 (Core.unName name) (Literals.showInt32 index))) - in (Logic.ifElse (Sets.member candidate reserved) (tryName (Math.add index 1)) candidate) - in (tryName 1) - --- | Look up an element in a graph -dereferenceElement :: Graph.Graph -> Core.Name -> Maybe Core.Binding -dereferenceElement graph name = lookupElement graph name - --- | Resolve a schema type through a chain of zero or more typedefs -dereferenceSchemaType :: Core.Name -> M.Map Core.Name Core.TypeScheme -> Maybe Core.TypeScheme -dereferenceSchemaType name types = - - let forType = - \t -> case t of - Core.TypeAnnotated v0 -> forType (Core.annotatedTypeBody v0) - Core.TypeForall v0 -> Maybes.map (\ts -> Core.TypeScheme { - Core.typeSchemeVariables = (Lists.cons (Core.forallTypeParameter v0) (Core.typeSchemeVariables ts)), - Core.typeSchemeType = (Core.typeSchemeType ts), - Core.typeSchemeConstraints = (Core.typeSchemeConstraints ts)}) (forType (Core.forallTypeBody v0)) - Core.TypeVariable v0 -> dereferenceSchemaType v0 types - _ -> Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = t, - Core.typeSchemeConstraints = Nothing}) - in (Maybes.bind (Maps.lookup name types) (\ts -> Maybes.map (\ts2 -> Core.TypeScheme { - Core.typeSchemeVariables = (Lists.concat2 (Core.typeSchemeVariables ts) (Core.typeSchemeVariables ts2)), - Core.typeSchemeType = (Core.typeSchemeType ts2), - Core.typeSchemeConstraints = (Core.typeSchemeConstraints ts2)}) (forType (Core.typeSchemeType ts)))) - --- | Look up a binding by name in a graph, returning Either an error or the binding -dereferenceVariable :: Graph.Graph -> Core.Name -> Either String Core.Binding -dereferenceVariable graph name = - Maybes.maybe (Left (Strings.cat2 "no such element: " (Core.unName name))) (\right_ -> Right right_) (lookupElement graph name) - --- | Create a graph from a parent graph, schema types, and list of element bindings -elementsToGraph :: Graph.Graph -> M.Map Core.Name Core.TypeScheme -> [Core.Binding] -> Graph.Graph -elementsToGraph parent schemaTypes elements = - - let prims = Graph.graphPrimitives parent - g = buildGraph elements Maps.empty prims - in Graph.Graph { - Graph.graphBoundTerms = (Graph.graphBoundTerms g), - Graph.graphBoundTypes = (Graph.graphBoundTypes g), - Graph.graphClassConstraints = (Graph.graphClassConstraints g), - Graph.graphLambdaVariables = (Graph.graphLambdaVariables g), - Graph.graphMetadata = (Graph.graphMetadata g), - Graph.graphPrimitives = (Graph.graphPrimitives g), - Graph.graphSchemaTypes = schemaTypes, - Graph.graphTypeVariables = (Graph.graphTypeVariables g)} - --- | An empty context; no trace, no messages, no other data. -emptyContext :: Context.Context -emptyContext = - Context.Context { - Context.contextTrace = [], - Context.contextMessages = [], - Context.contextOther = Maps.empty} - --- | An empty graph; no elements, no primitives, no schema. -emptyGraph :: Graph.Graph -emptyGraph = - Graph.Graph { - Graph.graphBoundTerms = Maps.empty, - Graph.graphBoundTypes = Maps.empty, - Graph.graphClassConstraints = Maps.empty, - Graph.graphLambdaVariables = Sets.empty, - Graph.graphMetadata = Maps.empty, - Graph.graphPrimitives = Maps.empty, - Graph.graphSchemaTypes = Maps.empty, - Graph.graphTypeVariables = Sets.empty} - --- | Extract the fields of a record or union type -fieldsOf :: Core.Type -> [Core.FieldType] -fieldsOf t = - - let stripped = Rewriting.deannotateType t - in case stripped of - Core.TypeForall v0 -> fieldsOf (Core.forallTypeBody v0) - Core.TypeRecord v0 -> v0 - Core.TypeUnion v0 -> v0 - _ -> [] - -getField :: Context.Context -> M.Map Core.Name t0 -> Core.Name -> (t0 -> Either (Context.InContext Errors.Error) t1) -> Either (Context.InContext Errors.Error) t1 -getField cx m fname decode = - Maybes.maybe (Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 "expected field " (Core.unName fname)) " not found"))), - Context.inContextContext = cx})) decode (Maps.lookup fname m) - --- | Reconstruct a list of Bindings from a Graph's boundTerms and boundTypes -graphToBindings :: Graph.Graph -> [Core.Binding] -graphToBindings g = - Lists.map (\p -> - let name = Pairs.first p - term = Pairs.second p - in Core.Binding { - Core.bindingName = name, - Core.bindingTerm = term, - Core.bindingType = (Maps.lookup name (Graph.graphBoundTypes g))}) (Maps.toList (Graph.graphBoundTerms g)) - --- | Look up a binding in a graph by name -lookupElement :: Graph.Graph -> Core.Name -> Maybe Core.Binding -lookupElement graph name = - Maybes.map (\term -> Core.Binding { - Core.bindingName = name, - Core.bindingTerm = term, - Core.bindingType = (Maps.lookup name (Graph.graphBoundTypes graph))}) (Maps.lookup name (Graph.graphBoundTerms graph)) - --- | Look up a primitive function in a graph by name -lookupPrimitive :: Graph.Graph -> Core.Name -> Maybe Graph.Primitive -lookupPrimitive graph name = Maps.lookup name (Graph.graphPrimitives graph) - --- | Look up a term by name in a graph -lookupTerm :: Graph.Graph -> Core.Name -> Maybe Core.Term -lookupTerm graph name = Maps.lookup name (Graph.graphBoundTerms graph) - -matchEnum :: Context.Context -> Graph.Graph -> Core.Name -> [(Core.Name, t0)] -> Core.Term -> Either (Context.InContext Errors.Error) t0 -matchEnum cx graph tname pairs = - matchUnion cx graph tname (Lists.map (\pair -> matchUnitField (Pairs.first pair) (Pairs.second pair)) pairs) - -matchRecord :: Context.Context -> t0 -> (M.Map Core.Name Core.Term -> Either (Context.InContext Errors.Error) t1) -> Core.Term -> Either (Context.InContext Errors.Error) t1 -matchRecord cx graph decode term = - - let stripped = Rewriting.deannotateAndDetypeTerm term - in case stripped of - Core.TermRecord v0 -> decode (Maps.fromList (Lists.map (\field -> (Core.fieldName field, (Core.fieldTerm field))) (Core.recordFields v0))) - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 "expected a record, got " (Core_.term term)))), - Context.inContextContext = cx}) - -matchUnion :: Context.Context -> Graph.Graph -> Core.Name -> [(Core.Name, (Core.Term -> Either (Context.InContext Errors.Error) t0))] -> Core.Term -> Either (Context.InContext Errors.Error) t0 -matchUnion cx graph tname pairs term = - - let stripped = Rewriting.deannotateAndDetypeTerm term - mapping = Maps.fromList pairs - in case stripped of - Core.TermVariable v0 -> Eithers.bind (requireElement cx graph v0) (\el -> matchUnion cx graph tname pairs (Core.bindingTerm el)) - Core.TermUnion v0 -> - let exp = - - let fname = Core.fieldName (Core.injectionField v0) - val = Core.fieldTerm (Core.injectionField v0) - in (Maybes.maybe (Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "no matching case for field \"" (Core.unName fname)) "\" in union type ") (Core.unName tname)))), - Context.inContextContext = cx})) (\f -> f val) (Maps.lookup fname mapping)) - in (Logic.ifElse (Equality.equal (Core.unName (Core.injectionTypeName v0)) (Core.unName tname)) exp (Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 (Strings.cat2 (Strings.cat2 "expected injection for type " (Core.unName tname)) ", got ") (Core_.term term)))), - Context.inContextContext = cx}))) - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat [ - "expected inject(", - (Core.unName tname), - ") with one of {", - (Strings.intercalate ", " (Lists.map (\pair -> Core.unName (Pairs.first pair)) pairs)), - "}, got ", - (Core_.term stripped)]))), - Context.inContextContext = cx}) - -matchUnitField :: t0 -> t1 -> (t0, (t2 -> Either t3 t1)) -matchUnitField fname x = (fname, (\ignored -> Right x)) - -requireElement :: Context.Context -> Graph.Graph -> Core.Name -> Either (Context.InContext Errors.Error) Core.Binding -requireElement cx graph name = - - let showAll = False - ellipsis = - \strings -> Logic.ifElse (Logic.and (Equality.gt (Lists.length strings) 3) (Logic.not showAll)) (Lists.concat2 (Lists.take 3 strings) [ - "..."]) strings - errMsg = - Strings.cat2 (Strings.cat2 (Strings.cat2 (Strings.cat2 "no such element: " (Core.unName name)) ". Available elements: {") (Strings.intercalate ", " (ellipsis (Lists.map Core.unName (Maps.keys (Graph.graphBoundTerms graph)))))) "}" - in (Maybes.maybe (Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError errMsg)), - Context.inContextContext = cx})) (\x -> Right x) (dereferenceElement graph name)) - -requirePrimitive :: Context.Context -> Graph.Graph -> Core.Name -> Either (Context.InContext Errors.Error) Graph.Primitive -requirePrimitive cx graph name = - Maybes.maybe (Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 "no such primitive function: " (Core.unName name)))), - Context.inContextContext = cx})) (\x -> Right x) (lookupPrimitive graph name) - -requirePrimitiveType :: Context.Context -> Graph.Graph -> Core.Name -> Either (Context.InContext Errors.Error) Core.TypeScheme -requirePrimitiveType cx tx name = - - let mts = Maybes.map (\_p -> Graph.primitiveType _p) (Maps.lookup name (Graph.graphPrimitives tx)) - in (Maybes.maybe (Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 "no such primitive function: " (Core.unName name)))), - Context.inContextContext = cx})) (\ts -> Right ts) mts) - -requireTerm :: Context.Context -> Graph.Graph -> Core.Name -> Either (Context.InContext Errors.Error) Core.Term -requireTerm cx graph name = - Maybes.maybe (Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 "no such element: " (Core.unName name)))), - Context.inContextContext = cx})) (\x -> Right x) (resolveTerm graph name) - --- | TODO: distinguish between lambda-bound and let-bound variables -resolveTerm :: Graph.Graph -> Core.Name -> Maybe Core.Term -resolveTerm graph name = - - let recurse = - \term -> - let stripped = Rewriting.deannotateTerm term - in case stripped of - Core.TermVariable v0 -> resolveTerm graph v0 - _ -> Just term - in (Maybes.maybe Nothing recurse (lookupTerm graph name)) - -stripAndDereferenceTerm :: Context.Context -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -stripAndDereferenceTerm cx graph term = - - let stripped = Rewriting.deannotateAndDetypeTerm term - in case stripped of - Core.TermVariable v0 -> Eithers.bind (requireTerm cx graph v0) (\t -> stripAndDereferenceTerm cx graph t) - _ -> Right stripped - --- | Strip annotations and dereference variables, returning Either an error or the resolved term -stripAndDereferenceTermEither :: Graph.Graph -> Core.Term -> Either String Core.Term -stripAndDereferenceTermEither graph term = - - let stripped = Rewriting.deannotateAndDetypeTerm term - in case stripped of - Core.TermVariable v0 -> Eithers.either (\left_ -> Left left_) (\binding -> stripAndDereferenceTermEither graph (Core.bindingTerm binding)) (dereferenceVariable graph v0) - _ -> Right stripped diff --git a/src/gen-main/haskell/Hydra/Lib/Names.hs b/src/gen-main/haskell/Hydra/Lib/Names.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Lib/Names.hs +++ /dev/null @@ -1,773 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Namespaces and primitive names for the Hydra standard library - -module Hydra.Lib.Names where - -import qualified Hydra.Core as Core -import qualified Hydra.Module as Module -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -chars :: Module.Namespace -chars = Module.Namespace "hydra.lib.chars" - -charsIsAlphaNum :: Core.Name -charsIsAlphaNum = Core.Name "hydra.lib.chars.isAlphaNum" - -charsIsLower :: Core.Name -charsIsLower = Core.Name "hydra.lib.chars.isLower" - -charsIsSpace :: Core.Name -charsIsSpace = Core.Name "hydra.lib.chars.isSpace" - -charsIsUpper :: Core.Name -charsIsUpper = Core.Name "hydra.lib.chars.isUpper" - -charsToLower :: Core.Name -charsToLower = Core.Name "hydra.lib.chars.toLower" - -charsToUpper :: Core.Name -charsToUpper = Core.Name "hydra.lib.chars.toUpper" - -eithers :: Module.Namespace -eithers = Module.Namespace "hydra.lib.eithers" - -eithersBimap :: Core.Name -eithersBimap = Core.Name "hydra.lib.eithers.bimap" - -eithersBind :: Core.Name -eithersBind = Core.Name "hydra.lib.eithers.bind" - -eithersEither :: Core.Name -eithersEither = Core.Name "hydra.lib.eithers.either" - -eithersFoldl :: Core.Name -eithersFoldl = Core.Name "hydra.lib.eithers.foldl" - -eithersFromLeft :: Core.Name -eithersFromLeft = Core.Name "hydra.lib.eithers.fromLeft" - -eithersFromRight :: Core.Name -eithersFromRight = Core.Name "hydra.lib.eithers.fromRight" - -eithersIsLeft :: Core.Name -eithersIsLeft = Core.Name "hydra.lib.eithers.isLeft" - -eithersIsRight :: Core.Name -eithersIsRight = Core.Name "hydra.lib.eithers.isRight" - -eithersLefts :: Core.Name -eithersLefts = Core.Name "hydra.lib.eithers.lefts" - -eithersMap :: Core.Name -eithersMap = Core.Name "hydra.lib.eithers.map" - -eithersMapList :: Core.Name -eithersMapList = Core.Name "hydra.lib.eithers.mapList" - -eithersMapMaybe :: Core.Name -eithersMapMaybe = Core.Name "hydra.lib.eithers.mapMaybe" - -eithersMapSet :: Core.Name -eithersMapSet = Core.Name "hydra.lib.eithers.mapSet" - -eithersPartitionEithers :: Core.Name -eithersPartitionEithers = Core.Name "hydra.lib.eithers.partitionEithers" - -eithersRights :: Core.Name -eithersRights = Core.Name "hydra.lib.eithers.rights" - -equality :: Module.Namespace -equality = Module.Namespace "hydra.lib.equality" - -equalityCompare :: Core.Name -equalityCompare = Core.Name "hydra.lib.equality.compare" - -equalityEqual :: Core.Name -equalityEqual = Core.Name "hydra.lib.equality.equal" - -equalityGt :: Core.Name -equalityGt = Core.Name "hydra.lib.equality.gt" - -equalityGte :: Core.Name -equalityGte = Core.Name "hydra.lib.equality.gte" - -equalityIdentity :: Core.Name -equalityIdentity = Core.Name "hydra.lib.equality.identity" - -equalityLt :: Core.Name -equalityLt = Core.Name "hydra.lib.equality.lt" - -equalityLte :: Core.Name -equalityLte = Core.Name "hydra.lib.equality.lte" - -equalityMax :: Core.Name -equalityMax = Core.Name "hydra.lib.equality.max" - -equalityMin :: Core.Name -equalityMin = Core.Name "hydra.lib.equality.min" - -lists :: Module.Namespace -lists = Module.Namespace "hydra.lib.lists" - -listsApply :: Core.Name -listsApply = Core.Name "hydra.lib.lists.apply" - -listsAt :: Core.Name -listsAt = Core.Name "hydra.lib.lists.at" - -listsBind :: Core.Name -listsBind = Core.Name "hydra.lib.lists.bind" - -listsConcat :: Core.Name -listsConcat = Core.Name "hydra.lib.lists.concat" - -listsConcat2 :: Core.Name -listsConcat2 = Core.Name "hydra.lib.lists.concat2" - -listsCons :: Core.Name -listsCons = Core.Name "hydra.lib.lists.cons" - -listsDrop :: Core.Name -listsDrop = Core.Name "hydra.lib.lists.drop" - -listsDropWhile :: Core.Name -listsDropWhile = Core.Name "hydra.lib.lists.dropWhile" - -listsElem :: Core.Name -listsElem = Core.Name "hydra.lib.lists.elem" - -listsFilter :: Core.Name -listsFilter = Core.Name "hydra.lib.lists.filter" - -listsFind :: Core.Name -listsFind = Core.Name "hydra.lib.lists.find" - -listsFoldl :: Core.Name -listsFoldl = Core.Name "hydra.lib.lists.foldl" - -listsFoldr :: Core.Name -listsFoldr = Core.Name "hydra.lib.lists.foldr" - -listsGroup :: Core.Name -listsGroup = Core.Name "hydra.lib.lists.group" - -listsHead :: Core.Name -listsHead = Core.Name "hydra.lib.lists.head" - -listsInit :: Core.Name -listsInit = Core.Name "hydra.lib.lists.init" - -listsIntercalate :: Core.Name -listsIntercalate = Core.Name "hydra.lib.lists.intercalate" - -listsIntersperse :: Core.Name -listsIntersperse = Core.Name "hydra.lib.lists.intersperse" - -listsLast :: Core.Name -listsLast = Core.Name "hydra.lib.lists.last" - -listsLength :: Core.Name -listsLength = Core.Name "hydra.lib.lists.length" - -listsMap :: Core.Name -listsMap = Core.Name "hydra.lib.lists.map" - -listsNub :: Core.Name -listsNub = Core.Name "hydra.lib.lists.nub" - -listsNull :: Core.Name -listsNull = Core.Name "hydra.lib.lists.null" - -listsPartition :: Core.Name -listsPartition = Core.Name "hydra.lib.lists.partition" - -listsPure :: Core.Name -listsPure = Core.Name "hydra.lib.lists.pure" - -listsReplicate :: Core.Name -listsReplicate = Core.Name "hydra.lib.lists.replicate" - -listsReverse :: Core.Name -listsReverse = Core.Name "hydra.lib.lists.reverse" - -listsSafeHead :: Core.Name -listsSafeHead = Core.Name "hydra.lib.lists.safeHead" - -listsSingleton :: Core.Name -listsSingleton = Core.Name "hydra.lib.lists.singleton" - -listsSort :: Core.Name -listsSort = Core.Name "hydra.lib.lists.sort" - -listsSortOn :: Core.Name -listsSortOn = Core.Name "hydra.lib.lists.sortOn" - -listsSpan :: Core.Name -listsSpan = Core.Name "hydra.lib.lists.span" - -listsTail :: Core.Name -listsTail = Core.Name "hydra.lib.lists.tail" - -listsTake :: Core.Name -listsTake = Core.Name "hydra.lib.lists.take" - -listsTranspose :: Core.Name -listsTranspose = Core.Name "hydra.lib.lists.transpose" - -listsZip :: Core.Name -listsZip = Core.Name "hydra.lib.lists.zip" - -listsZipWith :: Core.Name -listsZipWith = Core.Name "hydra.lib.lists.zipWith" - -literals :: Module.Namespace -literals = Module.Namespace "hydra.lib.literals" - -literalsBigfloatToBigint :: Core.Name -literalsBigfloatToBigint = Core.Name "hydra.lib.literals.bigfloatToBigint" - -literalsBigfloatToFloat32 :: Core.Name -literalsBigfloatToFloat32 = Core.Name "hydra.lib.literals.bigfloatToFloat32" - -literalsBigfloatToFloat64 :: Core.Name -literalsBigfloatToFloat64 = Core.Name "hydra.lib.literals.bigfloatToFloat64" - -literalsBigintToBigfloat :: Core.Name -literalsBigintToBigfloat = Core.Name "hydra.lib.literals.bigintToBigfloat" - -literalsBigintToInt16 :: Core.Name -literalsBigintToInt16 = Core.Name "hydra.lib.literals.bigintToInt16" - -literalsBigintToInt32 :: Core.Name -literalsBigintToInt32 = Core.Name "hydra.lib.literals.bigintToInt32" - -literalsBigintToInt64 :: Core.Name -literalsBigintToInt64 = Core.Name "hydra.lib.literals.bigintToInt64" - -literalsBigintToInt8 :: Core.Name -literalsBigintToInt8 = Core.Name "hydra.lib.literals.bigintToInt8" - -literalsBigintToUint16 :: Core.Name -literalsBigintToUint16 = Core.Name "hydra.lib.literals.bigintToUint16" - -literalsBigintToUint32 :: Core.Name -literalsBigintToUint32 = Core.Name "hydra.lib.literals.bigintToUint32" - -literalsBigintToUint64 :: Core.Name -literalsBigintToUint64 = Core.Name "hydra.lib.literals.bigintToUint64" - -literalsBigintToUint8 :: Core.Name -literalsBigintToUint8 = Core.Name "hydra.lib.literals.bigintToUint8" - -literalsBinaryToBytes :: Core.Name -literalsBinaryToBytes = Core.Name "hydra.lib.literals.binaryToBytes" - -literalsBinaryToString :: Core.Name -literalsBinaryToString = Core.Name "hydra.lib.literals.binaryToString" - -literalsFloat32ToBigfloat :: Core.Name -literalsFloat32ToBigfloat = Core.Name "hydra.lib.literals.float32ToBigfloat" - -literalsFloat64ToBigfloat :: Core.Name -literalsFloat64ToBigfloat = Core.Name "hydra.lib.literals.float64ToBigfloat" - -literalsInt16ToBigint :: Core.Name -literalsInt16ToBigint = Core.Name "hydra.lib.literals.int16ToBigint" - -literalsInt32ToBigint :: Core.Name -literalsInt32ToBigint = Core.Name "hydra.lib.literals.int32ToBigint" - -literalsInt64ToBigint :: Core.Name -literalsInt64ToBigint = Core.Name "hydra.lib.literals.int64ToBigint" - -literalsInt8ToBigint :: Core.Name -literalsInt8ToBigint = Core.Name "hydra.lib.literals.int8ToBigint" - -literalsReadBigfloat :: Core.Name -literalsReadBigfloat = Core.Name "hydra.lib.literals.readBigfloat" - -literalsReadBigint :: Core.Name -literalsReadBigint = Core.Name "hydra.lib.literals.readBigint" - -literalsReadBoolean :: Core.Name -literalsReadBoolean = Core.Name "hydra.lib.literals.readBoolean" - -literalsReadFloat32 :: Core.Name -literalsReadFloat32 = Core.Name "hydra.lib.literals.readFloat32" - -literalsReadFloat64 :: Core.Name -literalsReadFloat64 = Core.Name "hydra.lib.literals.readFloat64" - -literalsReadInt16 :: Core.Name -literalsReadInt16 = Core.Name "hydra.lib.literals.readInt16" - -literalsReadInt32 :: Core.Name -literalsReadInt32 = Core.Name "hydra.lib.literals.readInt32" - -literalsReadInt64 :: Core.Name -literalsReadInt64 = Core.Name "hydra.lib.literals.readInt64" - -literalsReadInt8 :: Core.Name -literalsReadInt8 = Core.Name "hydra.lib.literals.readInt8" - -literalsReadString :: Core.Name -literalsReadString = Core.Name "hydra.lib.literals.readString" - -literalsReadUint16 :: Core.Name -literalsReadUint16 = Core.Name "hydra.lib.literals.readUint16" - -literalsReadUint32 :: Core.Name -literalsReadUint32 = Core.Name "hydra.lib.literals.readUint32" - -literalsReadUint64 :: Core.Name -literalsReadUint64 = Core.Name "hydra.lib.literals.readUint64" - -literalsReadUint8 :: Core.Name -literalsReadUint8 = Core.Name "hydra.lib.literals.readUint8" - -literalsShowBigfloat :: Core.Name -literalsShowBigfloat = Core.Name "hydra.lib.literals.showBigfloat" - -literalsShowBigint :: Core.Name -literalsShowBigint = Core.Name "hydra.lib.literals.showBigint" - -literalsShowBoolean :: Core.Name -literalsShowBoolean = Core.Name "hydra.lib.literals.showBoolean" - -literalsShowFloat32 :: Core.Name -literalsShowFloat32 = Core.Name "hydra.lib.literals.showFloat32" - -literalsShowFloat64 :: Core.Name -literalsShowFloat64 = Core.Name "hydra.lib.literals.showFloat64" - -literalsShowInt16 :: Core.Name -literalsShowInt16 = Core.Name "hydra.lib.literals.showInt16" - -literalsShowInt32 :: Core.Name -literalsShowInt32 = Core.Name "hydra.lib.literals.showInt32" - -literalsShowInt64 :: Core.Name -literalsShowInt64 = Core.Name "hydra.lib.literals.showInt64" - -literalsShowInt8 :: Core.Name -literalsShowInt8 = Core.Name "hydra.lib.literals.showInt8" - -literalsShowString :: Core.Name -literalsShowString = Core.Name "hydra.lib.literals.showString" - -literalsShowUint16 :: Core.Name -literalsShowUint16 = Core.Name "hydra.lib.literals.showUint16" - -literalsShowUint32 :: Core.Name -literalsShowUint32 = Core.Name "hydra.lib.literals.showUint32" - -literalsShowUint64 :: Core.Name -literalsShowUint64 = Core.Name "hydra.lib.literals.showUint64" - -literalsShowUint8 :: Core.Name -literalsShowUint8 = Core.Name "hydra.lib.literals.showUint8" - -literalsStringToBinary :: Core.Name -literalsStringToBinary = Core.Name "hydra.lib.literals.stringToBinary" - -literalsUint16ToBigint :: Core.Name -literalsUint16ToBigint = Core.Name "hydra.lib.literals.uint16ToBigint" - -literalsUint32ToBigint :: Core.Name -literalsUint32ToBigint = Core.Name "hydra.lib.literals.uint32ToBigint" - -literalsUint64ToBigint :: Core.Name -literalsUint64ToBigint = Core.Name "hydra.lib.literals.uint64ToBigint" - -literalsUint8ToBigint :: Core.Name -literalsUint8ToBigint = Core.Name "hydra.lib.literals.uint8ToBigint" - -logic :: Module.Namespace -logic = Module.Namespace "hydra.lib.logic" - -logicAnd :: Core.Name -logicAnd = Core.Name "hydra.lib.logic.and" - -logicIfElse :: Core.Name -logicIfElse = Core.Name "hydra.lib.logic.ifElse" - -logicNot :: Core.Name -logicNot = Core.Name "hydra.lib.logic.not" - -logicOr :: Core.Name -logicOr = Core.Name "hydra.lib.logic.or" - -maps :: Module.Namespace -maps = Module.Namespace "hydra.lib.maps" - -mapsAlter :: Core.Name -mapsAlter = Core.Name "hydra.lib.maps.alter" - -mapsBimap :: Core.Name -mapsBimap = Core.Name "hydra.lib.maps.bimap" - -mapsDelete :: Core.Name -mapsDelete = Core.Name "hydra.lib.maps.delete" - -mapsElems :: Core.Name -mapsElems = Core.Name "hydra.lib.maps.elems" - -mapsEmpty :: Core.Name -mapsEmpty = Core.Name "hydra.lib.maps.empty" - -mapsFilter :: Core.Name -mapsFilter = Core.Name "hydra.lib.maps.filter" - -mapsFilterWithKey :: Core.Name -mapsFilterWithKey = Core.Name "hydra.lib.maps.filterWithKey" - -mapsFindWithDefault :: Core.Name -mapsFindWithDefault = Core.Name "hydra.lib.maps.findWithDefault" - -mapsFromList :: Core.Name -mapsFromList = Core.Name "hydra.lib.maps.fromList" - -mapsInsert :: Core.Name -mapsInsert = Core.Name "hydra.lib.maps.insert" - -mapsKeys :: Core.Name -mapsKeys = Core.Name "hydra.lib.maps.keys" - -mapsLookup :: Core.Name -mapsLookup = Core.Name "hydra.lib.maps.lookup" - -mapsMap :: Core.Name -mapsMap = Core.Name "hydra.lib.maps.map" - -mapsMapKeys :: Core.Name -mapsMapKeys = Core.Name "hydra.lib.maps.mapKeys" - -mapsMember :: Core.Name -mapsMember = Core.Name "hydra.lib.maps.member" - -mapsNull :: Core.Name -mapsNull = Core.Name "hydra.lib.maps.null" - -mapsSingleton :: Core.Name -mapsSingleton = Core.Name "hydra.lib.maps.singleton" - -mapsSize :: Core.Name -mapsSize = Core.Name "hydra.lib.maps.size" - -mapsToList :: Core.Name -mapsToList = Core.Name "hydra.lib.maps.toList" - -mapsUnion :: Core.Name -mapsUnion = Core.Name "hydra.lib.maps.union" - -math :: Module.Namespace -math = Module.Namespace "hydra.lib.math" - -mathAbs :: Core.Name -mathAbs = Core.Name "hydra.lib.math.abs" - -mathAcos :: Core.Name -mathAcos = Core.Name "hydra.lib.math.acos" - -mathAcosh :: Core.Name -mathAcosh = Core.Name "hydra.lib.math.acosh" - -mathAdd :: Core.Name -mathAdd = Core.Name "hydra.lib.math.add" - -mathAsin :: Core.Name -mathAsin = Core.Name "hydra.lib.math.asin" - -mathAsinh :: Core.Name -mathAsinh = Core.Name "hydra.lib.math.asinh" - -mathAtan :: Core.Name -mathAtan = Core.Name "hydra.lib.math.atan" - -mathAtan2 :: Core.Name -mathAtan2 = Core.Name "hydra.lib.math.atan2" - -mathAtanh :: Core.Name -mathAtanh = Core.Name "hydra.lib.math.atanh" - -mathCeiling :: Core.Name -mathCeiling = Core.Name "hydra.lib.math.ceiling" - -mathCos :: Core.Name -mathCos = Core.Name "hydra.lib.math.cos" - -mathCosh :: Core.Name -mathCosh = Core.Name "hydra.lib.math.cosh" - -mathDiv :: Core.Name -mathDiv = Core.Name "hydra.lib.math.div" - -mathE :: Core.Name -mathE = Core.Name "hydra.lib.math.e" - -mathEven :: Core.Name -mathEven = Core.Name "hydra.lib.math.even" - -mathExp :: Core.Name -mathExp = Core.Name "hydra.lib.math.exp" - -mathFloor :: Core.Name -mathFloor = Core.Name "hydra.lib.math.floor" - -mathLog :: Core.Name -mathLog = Core.Name "hydra.lib.math.log" - -mathLogBase :: Core.Name -mathLogBase = Core.Name "hydra.lib.math.logBase" - -mathMax :: Core.Name -mathMax = Core.Name "hydra.lib.math.max" - -mathMin :: Core.Name -mathMin = Core.Name "hydra.lib.math.min" - -mathMod :: Core.Name -mathMod = Core.Name "hydra.lib.math.mod" - -mathMul :: Core.Name -mathMul = Core.Name "hydra.lib.math.mul" - -mathNegate :: Core.Name -mathNegate = Core.Name "hydra.lib.math.negate" - -mathOdd :: Core.Name -mathOdd = Core.Name "hydra.lib.math.odd" - -mathPi :: Core.Name -mathPi = Core.Name "hydra.lib.math.pi" - -mathPow :: Core.Name -mathPow = Core.Name "hydra.lib.math.pow" - -mathPred :: Core.Name -mathPred = Core.Name "hydra.lib.math.pred" - -mathRange :: Core.Name -mathRange = Core.Name "hydra.lib.math.range" - -mathRem :: Core.Name -mathRem = Core.Name "hydra.lib.math.rem" - -mathRound :: Core.Name -mathRound = Core.Name "hydra.lib.math.round" - -mathRoundBigfloat :: Core.Name -mathRoundBigfloat = Core.Name "hydra.lib.math.roundBigfloat" - -mathRoundFloat32 :: Core.Name -mathRoundFloat32 = Core.Name "hydra.lib.math.roundFloat32" - -mathRoundFloat64 :: Core.Name -mathRoundFloat64 = Core.Name "hydra.lib.math.roundFloat64" - -mathSignum :: Core.Name -mathSignum = Core.Name "hydra.lib.math.signum" - -mathSin :: Core.Name -mathSin = Core.Name "hydra.lib.math.sin" - -mathSinh :: Core.Name -mathSinh = Core.Name "hydra.lib.math.sinh" - -mathSqrt :: Core.Name -mathSqrt = Core.Name "hydra.lib.math.sqrt" - -mathSub :: Core.Name -mathSub = Core.Name "hydra.lib.math.sub" - -mathSucc :: Core.Name -mathSucc = Core.Name "hydra.lib.math.succ" - -mathTan :: Core.Name -mathTan = Core.Name "hydra.lib.math.tan" - -mathTanh :: Core.Name -mathTanh = Core.Name "hydra.lib.math.tanh" - -mathTruncate :: Core.Name -mathTruncate = Core.Name "hydra.lib.math.truncate" - -maybes :: Module.Namespace -maybes = Module.Namespace "hydra.lib.maybes" - -maybesApply :: Core.Name -maybesApply = Core.Name "hydra.lib.maybes.apply" - -maybesBind :: Core.Name -maybesBind = Core.Name "hydra.lib.maybes.bind" - -maybesCases :: Core.Name -maybesCases = Core.Name "hydra.lib.maybes.cases" - -maybesCat :: Core.Name -maybesCat = Core.Name "hydra.lib.maybes.cat" - -maybesCompose :: Core.Name -maybesCompose = Core.Name "hydra.lib.maybes.compose" - -maybesFromJust :: Core.Name -maybesFromJust = Core.Name "hydra.lib.maybes.fromJust" - -maybesFromMaybe :: Core.Name -maybesFromMaybe = Core.Name "hydra.lib.maybes.fromMaybe" - -maybesIsJust :: Core.Name -maybesIsJust = Core.Name "hydra.lib.maybes.isJust" - -maybesIsNothing :: Core.Name -maybesIsNothing = Core.Name "hydra.lib.maybes.isNothing" - -maybesMap :: Core.Name -maybesMap = Core.Name "hydra.lib.maybes.map" - -maybesMapMaybe :: Core.Name -maybesMapMaybe = Core.Name "hydra.lib.maybes.mapMaybe" - -maybesMaybe :: Core.Name -maybesMaybe = Core.Name "hydra.lib.maybes.maybe" - -maybesPure :: Core.Name -maybesPure = Core.Name "hydra.lib.maybes.pure" - -maybesToList :: Core.Name -maybesToList = Core.Name "hydra.lib.maybes.toList" - -pairs :: Module.Namespace -pairs = Module.Namespace "hydra.lib.pairs" - -pairsBimap :: Core.Name -pairsBimap = Core.Name "hydra.lib.pairs.bimap" - -pairsFirst :: Core.Name -pairsFirst = Core.Name "hydra.lib.pairs.first" - -pairsSecond :: Core.Name -pairsSecond = Core.Name "hydra.lib.pairs.second" - -regex :: Module.Namespace -regex = Module.Namespace "hydra.lib.regex" - -regexFind :: Core.Name -regexFind = Core.Name "hydra.lib.regex.find" - -regexFindAll :: Core.Name -regexFindAll = Core.Name "hydra.lib.regex.findAll" - -regexMatches :: Core.Name -regexMatches = Core.Name "hydra.lib.regex.matches" - -regexReplace :: Core.Name -regexReplace = Core.Name "hydra.lib.regex.replace" - -regexReplaceAll :: Core.Name -regexReplaceAll = Core.Name "hydra.lib.regex.replaceAll" - -regexSplit :: Core.Name -regexSplit = Core.Name "hydra.lib.regex.split" - -sets :: Module.Namespace -sets = Module.Namespace "hydra.lib.sets" - -setsDelete :: Core.Name -setsDelete = Core.Name "hydra.lib.sets.delete" - -setsDifference :: Core.Name -setsDifference = Core.Name "hydra.lib.sets.difference" - -setsEmpty :: Core.Name -setsEmpty = Core.Name "hydra.lib.sets.empty" - -setsFromList :: Core.Name -setsFromList = Core.Name "hydra.lib.sets.fromList" - -setsInsert :: Core.Name -setsInsert = Core.Name "hydra.lib.sets.insert" - -setsIntersection :: Core.Name -setsIntersection = Core.Name "hydra.lib.sets.intersection" - -setsMap :: Core.Name -setsMap = Core.Name "hydra.lib.sets.map" - -setsMember :: Core.Name -setsMember = Core.Name "hydra.lib.sets.member" - -setsNull :: Core.Name -setsNull = Core.Name "hydra.lib.sets.null" - -setsSingleton :: Core.Name -setsSingleton = Core.Name "hydra.lib.sets.singleton" - -setsSize :: Core.Name -setsSize = Core.Name "hydra.lib.sets.size" - -setsToList :: Core.Name -setsToList = Core.Name "hydra.lib.sets.toList" - -setsUnion :: Core.Name -setsUnion = Core.Name "hydra.lib.sets.union" - -setsUnions :: Core.Name -setsUnions = Core.Name "hydra.lib.sets.unions" - -strings :: Module.Namespace -strings = Module.Namespace "hydra.lib.strings" - -stringsCat :: Core.Name -stringsCat = Core.Name "hydra.lib.strings.cat" - -stringsCat2 :: Core.Name -stringsCat2 = Core.Name "hydra.lib.strings.cat2" - -stringsCharAt :: Core.Name -stringsCharAt = Core.Name "hydra.lib.strings.charAt" - -stringsFromList :: Core.Name -stringsFromList = Core.Name "hydra.lib.strings.fromList" - -stringsIntercalate :: Core.Name -stringsIntercalate = Core.Name "hydra.lib.strings.intercalate" - -stringsLength :: Core.Name -stringsLength = Core.Name "hydra.lib.strings.length" - -stringsLines :: Core.Name -stringsLines = Core.Name "hydra.lib.strings.lines" - -stringsNull :: Core.Name -stringsNull = Core.Name "hydra.lib.strings.null" - -stringsSplitOn :: Core.Name -stringsSplitOn = Core.Name "hydra.lib.strings.splitOn" - -stringsToList :: Core.Name -stringsToList = Core.Name "hydra.lib.strings.toList" - -stringsToLower :: Core.Name -stringsToLower = Core.Name "hydra.lib.strings.toLower" - -stringsToUpper :: Core.Name -stringsToUpper = Core.Name "hydra.lib.strings.toUpper" - -stringsUnlines :: Core.Name -stringsUnlines = Core.Name "hydra.lib.strings.unlines" - -typeclass :: Module.Namespace -typeclass = Module.Namespace "hydra.typeclass" - -typeclassEq :: Core.Name -typeclassEq = Core.Name "hydra.typeclass.Eq" - -typeclassOrd :: Core.Name -typeclassOrd = Core.Name "hydra.typeclass.Ord" diff --git a/src/gen-main/haskell/Hydra/Literals.hs b/src/gen-main/haskell/Hydra/Literals.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Literals.hs +++ /dev/null @@ -1,58 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Conversion functions for literal values. - -module Hydra.Literals where - -import qualified Hydra.Core as Core -import qualified Hydra.Lib.Literals as Literals -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | Convert a bigfloat to a floating-point value of a given type (note: lossy) -bigfloatToFloatValue :: Core.FloatType -> Double -> Core.FloatValue -bigfloatToFloatValue ft bf = - case ft of - Core.FloatTypeBigfloat -> Core.FloatValueBigfloat bf - Core.FloatTypeFloat32 -> Core.FloatValueFloat32 (Literals.bigfloatToFloat32 bf) - Core.FloatTypeFloat64 -> Core.FloatValueFloat64 (Literals.bigfloatToFloat64 bf) - --- | Convert a bigint to an integer value of a given type (note: lossy) -bigintToIntegerValue :: Core.IntegerType -> Integer -> Core.IntegerValue -bigintToIntegerValue it bi = - case it of - Core.IntegerTypeBigint -> Core.IntegerValueBigint bi - Core.IntegerTypeInt8 -> Core.IntegerValueInt8 (Literals.bigintToInt8 bi) - Core.IntegerTypeInt16 -> Core.IntegerValueInt16 (Literals.bigintToInt16 bi) - Core.IntegerTypeInt32 -> Core.IntegerValueInt32 (Literals.bigintToInt32 bi) - Core.IntegerTypeInt64 -> Core.IntegerValueInt64 (Literals.bigintToInt64 bi) - Core.IntegerTypeUint8 -> Core.IntegerValueUint8 (Literals.bigintToUint8 bi) - Core.IntegerTypeUint16 -> Core.IntegerValueUint16 (Literals.bigintToUint16 bi) - Core.IntegerTypeUint32 -> Core.IntegerValueUint32 (Literals.bigintToUint32 bi) - Core.IntegerTypeUint64 -> Core.IntegerValueUint64 (Literals.bigintToUint64 bi) - --- | Convert a floating-point value of any precision to a bigfloat -floatValueToBigfloat :: Core.FloatValue -> Double -floatValueToBigfloat x = - case x of - Core.FloatValueBigfloat v0 -> v0 - Core.FloatValueFloat32 v0 -> Literals.float32ToBigfloat v0 - Core.FloatValueFloat64 v0 -> Literals.float64ToBigfloat v0 - --- | Convert an integer value of any precision to a bigint -integerValueToBigint :: Core.IntegerValue -> Integer -integerValueToBigint x = - case x of - Core.IntegerValueBigint v0 -> v0 - Core.IntegerValueInt8 v0 -> Literals.int8ToBigint v0 - Core.IntegerValueInt16 v0 -> Literals.int16ToBigint v0 - Core.IntegerValueInt32 v0 -> Literals.int32ToBigint v0 - Core.IntegerValueInt64 v0 -> Literals.int64ToBigint v0 - Core.IntegerValueUint8 v0 -> Literals.uint8ToBigint v0 - Core.IntegerValueUint16 v0 -> Literals.uint16ToBigint v0 - Core.IntegerValueUint32 v0 -> Literals.uint32ToBigint v0 - Core.IntegerValueUint64 v0 -> Literals.uint64ToBigint v0 diff --git a/src/gen-main/haskell/Hydra/Module.hs b/src/gen-main/haskell/Hydra/Module.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Module.hs +++ /dev/null @@ -1,153 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | A model for Hydra namespaces and modules - -module Hydra.Module where - -import qualified Hydra.Core as Core -import qualified Hydra.Graph as Graph -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | A definition, which may be either a term or type definition -data Definition = - -- | A term definition - DefinitionTerm TermDefinition | - -- | A type definition - DefinitionType TypeDefinition - deriving (Eq, Ord, Read, Show) - -_Definition = Core.Name "hydra.module.Definition" - -_Definition_term = Core.Name "term" - -_Definition_type = Core.Name "type" - --- | A file extension (without the dot), e.g. "json" or "py" -newtype FileExtension = - FileExtension { - unFileExtension :: String} - deriving (Eq, Ord, Read, Show) - -_FileExtension = Core.Name "hydra.module.FileExtension" - --- | A library of primitive functions -data Library = - Library { - -- | A common prefix for all primitive function names in the library - libraryNamespace :: Namespace, - -- | A preferred namespace prefix for function names in the library - libraryPrefix :: String, - -- | The primitives defined in this library - libraryPrimitives :: [Graph.Primitive]} - -_Library = Core.Name "hydra.module.Library" - -_Library_namespace = Core.Name "namespace" - -_Library_prefix = Core.Name "prefix" - -_Library_primitives = Core.Name "primitives" - --- | A logical collection of elements in the same namespace, having dependencies on zero or more other modules -data Module = - Module { - -- | A common prefix for all element names in the module - moduleNamespace :: Namespace, - -- | The definitions in this module - moduleDefinitions :: [Definition], - -- | Any modules which the term expressions of this module directly depend upon - moduleTermDependencies :: [Namespace], - -- | Any modules which the type expressions of this module directly depend upon - moduleTypeDependencies :: [Namespace], - -- | An optional human-readable description of the module - moduleDescription :: (Maybe String)} - deriving (Eq, Ord, Read, Show) - -_Module = Core.Name "hydra.module.Module" - -_Module_namespace = Core.Name "namespace" - -_Module_definitions = Core.Name "definitions" - -_Module_termDependencies = Core.Name "termDependencies" - -_Module_typeDependencies = Core.Name "typeDependencies" - -_Module_description = Core.Name "description" - --- | A prefix for element names -newtype Namespace = - Namespace { - unNamespace :: String} - deriving (Eq, Ord, Read, Show) - -_Namespace = Core.Name "hydra.module.Namespace" - --- | A mapping from namespaces to values of type n, with a focus on one namespace -data Namespaces n = - Namespaces { - -- | The namespace in focus, together with its associated value - namespacesFocus :: (Namespace, n), - -- | A mapping of namespaces to values - namespacesMapping :: (M.Map Namespace n)} - deriving (Eq, Ord, Read, Show) - -_Namespaces = Core.Name "hydra.module.Namespaces" - -_Namespaces_focus = Core.Name "focus" - -_Namespaces_mapping = Core.Name "mapping" - --- | A qualified name consisting of an optional namespace together with a mandatory local name -data QualifiedName = - QualifiedName { - -- | The optional namespace - qualifiedNameNamespace :: (Maybe Namespace), - -- | The local name - qualifiedNameLocal :: String} - deriving (Eq, Ord, Read, Show) - -_QualifiedName = Core.Name "hydra.module.QualifiedName" - -_QualifiedName_namespace = Core.Name "namespace" - -_QualifiedName_local = Core.Name "local" - --- | A term-level definition, including a name, a term, and the type scheme of the term -data TermDefinition = - TermDefinition { - -- | The name of the term - termDefinitionName :: Core.Name, - -- | The term being defined - termDefinitionTerm :: Core.Term, - -- | The type scheme of the term, including any class constraints - termDefinitionType :: (Maybe Core.TypeScheme)} - deriving (Eq, Ord, Read, Show) - -_TermDefinition = Core.Name "hydra.module.TermDefinition" - -_TermDefinition_name = Core.Name "name" - -_TermDefinition_term = Core.Name "term" - -_TermDefinition_type = Core.Name "type" - --- | A type-level definition, including a name and the type -data TypeDefinition = - TypeDefinition { - -- | The name of the type - typeDefinitionName :: Core.Name, - -- | The type being defined - typeDefinitionType :: Core.Type} - deriving (Eq, Ord, Read, Show) - -_TypeDefinition = Core.Name "hydra.module.TypeDefinition" - -_TypeDefinition_name = Core.Name "name" - -_TypeDefinition_type = Core.Name "type" diff --git a/src/gen-main/haskell/Hydra/Names.hs b/src/gen-main/haskell/Hydra/Names.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Names.hs +++ /dev/null @@ -1,80 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Functions for working with qualified names. - -module Hydra.Names where - -import qualified Hydra.Core as Core -import qualified Hydra.Formatting as Formatting -import qualified Hydra.Lib.Equality as Equality -import qualified Hydra.Lib.Lists as Lists -import qualified Hydra.Lib.Logic as Logic -import qualified Hydra.Lib.Maps as Maps -import qualified Hydra.Lib.Maybes as Maybes -import qualified Hydra.Lib.Sets as Sets -import qualified Hydra.Lib.Strings as Strings -import qualified Hydra.Module as Module -import qualified Hydra.Util as Util -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | Given a mapping of namespaces to prefixes, convert a name to a compact string representation -compactName :: M.Map Module.Namespace String -> Core.Name -> String -compactName namespaces name = - - let qualName = qualifyName name - mns = Module.qualifiedNameNamespace qualName - local = Module.qualifiedNameLocal qualName - in (Maybes.maybe (Core.unName name) (\ns -> Maybes.maybe local (\pre -> Strings.cat [ - pre, - ":", - local]) (Maps.lookup ns namespaces)) mns) - --- | Extract the local part of a name -localNameOf :: Core.Name -> String -localNameOf arg_ = Module.qualifiedNameLocal (qualifyName arg_) - --- | Extract the namespace of a name, if any -namespaceOf :: Core.Name -> Maybe Module.Namespace -namespaceOf arg_ = Module.qualifiedNameNamespace (qualifyName arg_) - --- | Convert a namespace to a file path with the given case convention and file extension -namespaceToFilePath :: Util.CaseConvention -> Module.FileExtension -> Module.Namespace -> String -namespaceToFilePath caseConv ext ns = - - let parts = Lists.map (Formatting.convertCase Util.CaseConventionCamel caseConv) (Strings.splitOn "." (Module.unNamespace ns)) - in (Strings.cat2 (Strings.cat2 (Strings.intercalate "/" parts) ".") (Module.unFileExtension ext)) - --- | Construct a qualified (dot-separated) name -qname :: Module.Namespace -> String -> Core.Name -qname ns name = - Core.Name (Strings.cat [ - Module.unNamespace ns, - ".", - name]) - --- | Split a dot-separated name into a namespace and local name -qualifyName :: Core.Name -> Module.QualifiedName -qualifyName name = - - let parts = Lists.reverse (Strings.splitOn "." (Core.unName name)) - in (Logic.ifElse (Equality.equal 1 (Lists.length parts)) (Module.QualifiedName { - Module.qualifiedNameNamespace = Nothing, - Module.qualifiedNameLocal = (Core.unName name)}) (Module.QualifiedName { - Module.qualifiedNameNamespace = (Just (Module.Namespace (Strings.intercalate "." (Lists.reverse (Lists.tail parts))))), - Module.qualifiedNameLocal = (Lists.head parts)})) - --- | Generate a unique label by appending a suffix if the label is already in use -uniqueLabel :: S.Set String -> String -> String -uniqueLabel visited l = Logic.ifElse (Sets.member l visited) (uniqueLabel visited (Strings.cat2 l "'")) l - --- | Convert a qualified name to a dot-separated name -unqualifyName :: Module.QualifiedName -> Core.Name -unqualifyName qname = - - let prefix = Maybes.maybe "" (\n -> Strings.cat2 (Module.unNamespace n) ".") (Module.qualifiedNameNamespace qname) - in (Core.Name (Strings.cat2 prefix (Module.qualifiedNameLocal qname))) diff --git a/src/gen-main/haskell/Hydra/Packaging.hs b/src/gen-main/haskell/Hydra/Packaging.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Packaging.hs +++ /dev/null @@ -1,45 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | A model for Hydra packages - -module Hydra.Packaging where - -import qualified Hydra.Core as Core -import qualified Hydra.Module as Module -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | A package, which is a named collection of modules with metadata and dependencies -data Package = - Package { - -- | The name of the package - packageName :: PackageName, - -- | The modules in this package - packageModules :: [Module.Module], - -- | The packages which this package depends on - packageDependencies :: [PackageName], - -- | An optional human-readable description of the package - packageDescription :: (Maybe String)} - deriving (Eq, Ord, Read, Show) - -_Package = Core.Name "hydra.packaging.Package" - -_Package_name = Core.Name "name" - -_Package_modules = Core.Name "modules" - -_Package_dependencies = Core.Name "dependencies" - -_Package_description = Core.Name "description" - --- | The unique name of a package, e.g. "hydra-kernel" or "hydra-python" -newtype PackageName = - PackageName { - unPackageName :: String} - deriving (Eq, Ord, Read, Show) - -_PackageName = Core.Name "hydra.packaging.PackageName" diff --git a/src/gen-main/haskell/Hydra/Parsers.hs b/src/gen-main/haskell/Hydra/Parsers.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Parsers.hs +++ /dev/null @@ -1,163 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | General-purpose parser combinators - -module Hydra.Parsers where - -import qualified Hydra.Lib.Equality as Equality -import qualified Hydra.Lib.Lists as Lists -import qualified Hydra.Lib.Logic as Logic -import qualified Hydra.Lib.Maybes as Maybes -import qualified Hydra.Lib.Strings as Strings -import qualified Hydra.Parsing as Parsing -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | Try the first parser; if it fails without consuming input, try the second -alt :: Parsing.Parser t0 -> Parsing.Parser t0 -> Parsing.Parser t0 -alt p1 p2 = - - let parse = - \input -> (\x -> case x of - Parsing.ParseResultSuccess v0 -> Parsing.ParseResultSuccess v0 - Parsing.ParseResultFailure v0 -> Logic.ifElse (Equality.equal (Parsing.parseErrorRemainder v0) input) (Parsing.unParser p2 input) (Parsing.ParseResultFailure v0)) (Parsing.unParser p1 input) - in (Parsing.Parser parse) - --- | Parse any single character (codepoint) -anyChar :: Parsing.Parser Int -anyChar = satisfy (\_ -> True) - --- | Apply a parser containing a function to a parser containing a value -apply :: Parsing.Parser (t0 -> t1) -> Parsing.Parser t0 -> Parsing.Parser t1 -apply pf pa = - - let parse = - \input -> (\x -> case x of - Parsing.ParseResultSuccess v0 -> (\x -> case x of - Parsing.ParseResultSuccess v1 -> Parsing.ParseResultSuccess (Parsing.ParseSuccess { - Parsing.parseSuccessValue = (Parsing.parseSuccessValue v0 (Parsing.parseSuccessValue v1)), - Parsing.parseSuccessRemainder = (Parsing.parseSuccessRemainder v1)}) - Parsing.ParseResultFailure v1 -> Parsing.ParseResultFailure v1) (Parsing.unParser pa (Parsing.parseSuccessRemainder v0)) - Parsing.ParseResultFailure v0 -> Parsing.ParseResultFailure v0) (Parsing.unParser pf input) - in (Parsing.Parser parse) - --- | Parse something between an opening and closing parser -between :: Parsing.Parser t0 -> Parsing.Parser t1 -> Parsing.Parser t2 -> Parsing.Parser t2 -between open close p = bind open (\_ -> bind p (\x -> bind close (\_ -> pure x))) - --- | Sequence two parsers, passing the result of the first to a function that produces the second -bind :: Parsing.Parser t0 -> (t0 -> Parsing.Parser t1) -> Parsing.Parser t1 -bind pa f = - - let parse = - \input -> (\x -> case x of - Parsing.ParseResultSuccess v0 -> Parsing.unParser (f (Parsing.parseSuccessValue v0)) (Parsing.parseSuccessRemainder v0) - Parsing.ParseResultFailure v0 -> Parsing.ParseResultFailure v0) (Parsing.unParser pa input) - in (Parsing.Parser parse) - --- | Parse a specific character (codepoint) -char :: Int -> Parsing.Parser Int -char c = satisfy (\x -> Equality.equal x c) - --- | Try each parser in the list until one succeeds -choice :: [Parsing.Parser t0] -> Parsing.Parser t0 -choice ps = Lists.foldl alt (fail "no choice matched") ps - --- | A parser that succeeds only at the end of input -eof :: Parsing.Parser () -eof = - Parsing.Parser (\input -> Logic.ifElse (Equality.equal input "") (Parsing.ParseResultSuccess (Parsing.ParseSuccess { - Parsing.parseSuccessValue = (), - Parsing.parseSuccessRemainder = ""})) (Parsing.ParseResultFailure (Parsing.ParseError { - Parsing.parseErrorMessage = "expected end of input", - Parsing.parseErrorRemainder = input}))) - --- | A parser that always fails with the given error message -fail :: String -> Parsing.Parser t0 -fail msg = - Parsing.Parser (\input -> Parsing.ParseResultFailure (Parsing.ParseError { - Parsing.parseErrorMessage = msg, - Parsing.parseErrorRemainder = input})) - --- | Create a parser that defers construction of another parser until parsing time. This is essential for breaking recursive parser definitions. -lazy :: (() -> Parsing.Parser t0) -> Parsing.Parser t0 -lazy f = Parsing.Parser (\input -> Parsing.unParser (f ()) input) - --- | Parse zero or more occurrences of the given parser -many :: Parsing.Parser t0 -> Parsing.Parser [t0] -many p = alt (some p) (pure []) - --- | Apply a function to the result of a parser -map :: (t0 -> t1) -> Parsing.Parser t0 -> Parsing.Parser t1 -map f pa = - - let parse = - \input -> (\x -> case x of - Parsing.ParseResultSuccess v0 -> Parsing.ParseResultSuccess (Parsing.ParseSuccess { - Parsing.parseSuccessValue = (f (Parsing.parseSuccessValue v0)), - Parsing.parseSuccessRemainder = (Parsing.parseSuccessRemainder v0)}) - Parsing.ParseResultFailure v0 -> Parsing.ParseResultFailure v0) (Parsing.unParser pa input) - in (Parsing.Parser parse) - --- | Optionally parse something, returning Nothing if it fails -optional :: Parsing.Parser t0 -> Parsing.Parser (Maybe t0) -optional p = alt (map Maybes.pure p) (pure Nothing) - --- | A parser that always succeeds with the given value without consuming input -pure :: t0 -> Parsing.Parser t0 -pure a = - Parsing.Parser (\input -> Parsing.ParseResultSuccess (Parsing.ParseSuccess { - Parsing.parseSuccessValue = a, - Parsing.parseSuccessRemainder = input})) - --- | Run a parser on the given input string -runParser :: Parsing.Parser t0 -> String -> Parsing.ParseResult t0 -runParser p input = Parsing.unParser p input - --- | Parse a character (codepoint) that satisfies the given predicate -satisfy :: (Int -> Bool) -> Parsing.Parser Int -satisfy pred = - - let parse = - \input -> - let codes = Strings.toList input - in (Maybes.maybe (Parsing.ParseResultFailure (Parsing.ParseError { - Parsing.parseErrorMessage = "unexpected end of input", - Parsing.parseErrorRemainder = input})) (\c -> - let rest = Strings.fromList (Lists.drop 1 codes) - in (Logic.ifElse (pred c) (Parsing.ParseResultSuccess (Parsing.ParseSuccess { - Parsing.parseSuccessValue = c, - Parsing.parseSuccessRemainder = rest})) (Parsing.ParseResultFailure (Parsing.ParseError { - Parsing.parseErrorMessage = "character did not satisfy predicate", - Parsing.parseErrorRemainder = input})))) (Lists.safeHead codes)) - in (Parsing.Parser parse) - --- | Parse zero or more occurrences separated by a separator -sepBy :: Parsing.Parser t0 -> Parsing.Parser t1 -> Parsing.Parser [t0] -sepBy p sep = alt (sepBy1 p sep) (pure []) - --- | Parse one or more occurrences separated by a separator -sepBy1 :: Parsing.Parser t0 -> Parsing.Parser t1 -> Parsing.Parser [t0] -sepBy1 p sep = bind p (\x -> bind (many (bind sep (\_ -> p))) (\xs -> pure (Lists.cons x xs))) - --- | Parse one or more occurrences of the given parser -some :: Parsing.Parser t0 -> Parsing.Parser [t0] -some p = bind p (\x -> bind (many p) (\xs -> pure (Lists.cons x xs))) - --- | Parse a specific string -string :: String -> Parsing.Parser String -string str = - Parsing.Parser (\input -> - let strCodes = Strings.toList str - inputCodes = Strings.toList input - strLen = Lists.length strCodes - inputPrefix = Lists.take strLen inputCodes - in (Logic.ifElse (Equality.equal strCodes inputPrefix) (Parsing.ParseResultSuccess (Parsing.ParseSuccess { - Parsing.parseSuccessValue = str, - Parsing.parseSuccessRemainder = (Strings.fromList (Lists.drop strLen inputCodes))})) (Parsing.ParseResultFailure (Parsing.ParseError { - Parsing.parseErrorMessage = (Strings.cat2 "expected: " str), - Parsing.parseErrorRemainder = input})))) diff --git a/src/gen-main/haskell/Hydra/Parsing.hs b/src/gen-main/haskell/Hydra/Parsing.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Parsing.hs +++ /dev/null @@ -1,64 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Parser combinator types for text parsing - -module Hydra.Parsing where - -import qualified Hydra.Core as Core -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | An error which occurred while parsing -data ParseError = - ParseError { - -- | An error message - parseErrorMessage :: String, - -- | The remaining input at the point of failure - parseErrorRemainder :: String} - deriving (Eq, Ord, Read, Show) - -_ParseError = Core.Name "hydra.parsing.ParseError" - -_ParseError_message = Core.Name "message" - -_ParseError_remainder = Core.Name "remainder" - --- | The result of a parse operation -data ParseResult a = - -- | A successful parse, with a value and the remaining unparsed input - ParseResultSuccess (ParseSuccess a) | - -- | A failed parse, with an error message and the remaining input - ParseResultFailure ParseError - deriving (Eq, Ord, Read, Show) - -_ParseResult = Core.Name "hydra.parsing.ParseResult" - -_ParseResult_success = Core.Name "success" - -_ParseResult_failure = Core.Name "failure" - --- | A successful parse result -data ParseSuccess a = - ParseSuccess { - -- | The parsed value - parseSuccessValue :: a, - -- | The remaining unparsed input - parseSuccessRemainder :: String} - deriving (Eq, Ord, Read, Show) - -_ParseSuccess = Core.Name "hydra.parsing.ParseSuccess" - -_ParseSuccess_value = Core.Name "value" - -_ParseSuccess_remainder = Core.Name "remainder" - --- | A parser which consumes characters from a string and produces a value -newtype Parser a = - Parser { - unParser :: (String -> ParseResult a)} - -_Parser = Core.Name "hydra.parsing.Parser" diff --git a/src/gen-main/haskell/Hydra/Paths.hs b/src/gen-main/haskell/Hydra/Paths.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Paths.hs +++ /dev/null @@ -1,299 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | A model for subterm and subtype access patterns - -module Hydra.Paths where - -import qualified Hydra.Core as Core -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | An edge in a subterm graph, connecting two nodes via a path -data SubtermEdge = - SubtermEdge { - -- | The source node of the edge - subtermEdgeSource :: SubtermNode, - -- | The subterm path connecting source to target - subtermEdgePath :: SubtermPath, - -- | The target node of the edge - subtermEdgeTarget :: SubtermNode} - deriving (Eq, Ord, Read, Show) - -_SubtermEdge = Core.Name "hydra.paths.SubtermEdge" - -_SubtermEdge_source = Core.Name "source" - -_SubtermEdge_path = Core.Name "path" - -_SubtermEdge_target = Core.Name "target" - --- | A graph of subterm nodes and edges, representing term access patterns -data SubtermGraph = - SubtermGraph { - -- | All nodes in the graph - subtermGraphNodes :: [SubtermNode], - -- | All edges in the graph - subtermGraphEdges :: [SubtermEdge]} - deriving (Eq, Ord, Read, Show) - -_SubtermGraph = Core.Name "hydra.paths.SubtermGraph" - -_SubtermGraph_nodes = Core.Name "nodes" - -_SubtermGraph_edges = Core.Name "edges" - --- | A node in a subterm graph, representing a term or subterm -data SubtermNode = - SubtermNode { - -- | The qualified name of the term - subtermNodeName :: Core.Name, - -- | A human-readable label for the node - subtermNodeLabel :: String, - -- | A unique identifier for the node - subtermNodeId :: String} - deriving (Eq, Ord, Read, Show) - -_SubtermNode = Core.Name "hydra.paths.SubtermNode" - -_SubtermNode_name = Core.Name "name" - -_SubtermNode_label = Core.Name "label" - -_SubtermNode_id = Core.Name "id" - --- | A sequence of subterm steps forming a path through a term -newtype SubtermPath = - SubtermPath { - unSubtermPath :: [SubtermStep]} - deriving (Eq, Ord, Read, Show) - -_SubtermPath = Core.Name "hydra.paths.SubtermPath" - --- | A function which maps from a term to a particular immediate subterm -data SubtermStep = - -- | Access the body of an annotated term - SubtermStepAnnotatedBody | - -- | Access the function of an application term - SubtermStepApplicationFunction | - -- | Access the argument of an application term - SubtermStepApplicationArgument | - -- | Access the body of a lambda term - SubtermStepLambdaBody | - -- | Access the default case of a union elimination - SubtermStepUnionCasesDefault | - -- | Access a specific branch of a union elimination by field name - SubtermStepUnionCasesBranch Core.Name | - -- | Access the body of a let term - SubtermStepLetBody | - -- | Access a specific binding in a let term by variable name - SubtermStepLetBinding Core.Name | - -- | Access an element of a list by index - SubtermStepListElement Int | - -- | Access a key in a map by index - SubtermStepMapKey Int | - -- | Access a value in a map by index - SubtermStepMapValue Int | - -- | Access the term inside a Just value - SubtermStepMaybeTerm | - -- | Access an element of a product (tuple) by index - SubtermStepProductTerm Int | - -- | Access a field of a record by field name - SubtermStepRecordField Core.Name | - -- | Access an element of a set by index - SubtermStepSetElement Int | - -- | Access the term inside a sum variant - SubtermStepSumTerm | - -- | Access the body of a type lambda term - SubtermStepTypeLambdaBody | - -- | Access the term being applied to a type - SubtermStepTypeApplicationTerm | - -- | Access the term inside a union injection - SubtermStepInjectionTerm | - -- | Access the term inside a wrapped term - SubtermStepWrappedTerm - deriving (Eq, Ord, Read, Show) - -_SubtermStep = Core.Name "hydra.paths.SubtermStep" - -_SubtermStep_annotatedBody = Core.Name "annotatedBody" - -_SubtermStep_applicationFunction = Core.Name "applicationFunction" - -_SubtermStep_applicationArgument = Core.Name "applicationArgument" - -_SubtermStep_lambdaBody = Core.Name "lambdaBody" - -_SubtermStep_unionCasesDefault = Core.Name "unionCasesDefault" - -_SubtermStep_unionCasesBranch = Core.Name "unionCasesBranch" - -_SubtermStep_letBody = Core.Name "letBody" - -_SubtermStep_letBinding = Core.Name "letBinding" - -_SubtermStep_listElement = Core.Name "listElement" - -_SubtermStep_mapKey = Core.Name "mapKey" - -_SubtermStep_mapValue = Core.Name "mapValue" - -_SubtermStep_maybeTerm = Core.Name "maybeTerm" - -_SubtermStep_productTerm = Core.Name "productTerm" - -_SubtermStep_recordField = Core.Name "recordField" - -_SubtermStep_setElement = Core.Name "setElement" - -_SubtermStep_sumTerm = Core.Name "sumTerm" - -_SubtermStep_typeLambdaBody = Core.Name "typeLambdaBody" - -_SubtermStep_typeApplicationTerm = Core.Name "typeApplicationTerm" - -_SubtermStep_injectionTerm = Core.Name "injectionTerm" - -_SubtermStep_wrappedTerm = Core.Name "wrappedTerm" - --- | An edge in a subtype graph, connecting two nodes via a path -data SubtypeEdge = - SubtypeEdge { - -- | The source node of the edge - subtypeEdgeSource :: SubtypeNode, - -- | The subtype path connecting source to target - subtypeEdgePath :: SubtypePath, - -- | The target node of the edge - subtypeEdgeTarget :: SubtypeNode} - deriving (Eq, Ord, Read, Show) - -_SubtypeEdge = Core.Name "hydra.paths.SubtypeEdge" - -_SubtypeEdge_source = Core.Name "source" - -_SubtypeEdge_path = Core.Name "path" - -_SubtypeEdge_target = Core.Name "target" - --- | A graph of subtype nodes and edges, representing type access patterns -data SubtypeGraph = - SubtypeGraph { - -- | All nodes in the graph - subtypeGraphNodes :: [SubtypeNode], - -- | All edges in the graph - subtypeGraphEdges :: [SubtypeEdge]} - deriving (Eq, Ord, Read, Show) - -_SubtypeGraph = Core.Name "hydra.paths.SubtypeGraph" - -_SubtypeGraph_nodes = Core.Name "nodes" - -_SubtypeGraph_edges = Core.Name "edges" - --- | A node in a subtype graph, representing a type or subtype -data SubtypeNode = - SubtypeNode { - -- | The qualified name of the type - subtypeNodeName :: Core.Name, - -- | A human-readable label for the node - subtypeNodeLabel :: String, - -- | A unique identifier for the node - subtypeNodeId :: String} - deriving (Eq, Ord, Read, Show) - -_SubtypeNode = Core.Name "hydra.paths.SubtypeNode" - -_SubtypeNode_name = Core.Name "name" - -_SubtypeNode_label = Core.Name "label" - -_SubtypeNode_id = Core.Name "id" - --- | A sequence of subtype steps forming a path through a type -newtype SubtypePath = - SubtypePath { - unSubtypePath :: [SubtypeStep]} - deriving (Eq, Ord, Read, Show) - -_SubtypePath = Core.Name "hydra.paths.SubtypePath" - --- | A function which maps from a type to a particular immediate subtype -data SubtypeStep = - -- | Access the body of an annotated type - SubtypeStepAnnotatedBody | - -- | Access the function of an application type - SubtypeStepApplicationFunction | - -- | Access the argument of an application type - SubtypeStepApplicationArgument | - -- | Access the left type of an either type - SubtypeStepEitherLeft | - -- | Access the right type of an either type - SubtypeStepEitherRight | - -- | Access the body of a universally quantified type - SubtypeStepForallBody | - -- | Access the domain type of a function type - SubtypeStepFunctionDomain | - -- | Access the codomain type of a function type - SubtypeStepFunctionCodomain | - -- | Access the element type of a list type - SubtypeStepListElement | - -- | Access the key type of a map type - SubtypeStepMapKeys | - -- | Access the value type of a map type - SubtypeStepMapValues | - -- | Access the element type of an optional type - SubtypeStepMaybeElement | - -- | Access the first type of a pair type - SubtypeStepPairFirst | - -- | Access the second type of a pair type - SubtypeStepPairSecond | - -- | Access a field type of a record type by field name - SubtypeStepRecordField Core.Name | - -- | Access the element type of a set type - SubtypeStepSetElement | - -- | Access a field type of a union type by field name - SubtypeStepUnionField Core.Name | - -- | Access the type inside a wrapped type - SubtypeStepWrappedType - deriving (Eq, Ord, Read, Show) - -_SubtypeStep = Core.Name "hydra.paths.SubtypeStep" - -_SubtypeStep_annotatedBody = Core.Name "annotatedBody" - -_SubtypeStep_applicationFunction = Core.Name "applicationFunction" - -_SubtypeStep_applicationArgument = Core.Name "applicationArgument" - -_SubtypeStep_eitherLeft = Core.Name "eitherLeft" - -_SubtypeStep_eitherRight = Core.Name "eitherRight" - -_SubtypeStep_forallBody = Core.Name "forallBody" - -_SubtypeStep_functionDomain = Core.Name "functionDomain" - -_SubtypeStep_functionCodomain = Core.Name "functionCodomain" - -_SubtypeStep_listElement = Core.Name "listElement" - -_SubtypeStep_mapKeys = Core.Name "mapKeys" - -_SubtypeStep_mapValues = Core.Name "mapValues" - -_SubtypeStep_maybeElement = Core.Name "maybeElement" - -_SubtypeStep_pairFirst = Core.Name "pairFirst" - -_SubtypeStep_pairSecond = Core.Name "pairSecond" - -_SubtypeStep_recordField = Core.Name "recordField" - -_SubtypeStep_setElement = Core.Name "setElement" - -_SubtypeStep_unionField = Core.Name "unionField" - -_SubtypeStep_wrappedType = Core.Name "wrappedType" diff --git a/src/gen-main/haskell/Hydra/Phantoms.hs b/src/gen-main/haskell/Hydra/Phantoms.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Phantoms.hs +++ /dev/null @@ -1,36 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Phantom types for use with Hydra DSLs - -module Hydra.Phantoms where - -import qualified Hydra.Core as Core -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | An association of a named term (element) with a phantom type -data TBinding a = - TBinding { - -- | The name of the term - tBindingName :: Core.Name, - -- | The term with its phantom type - tBindingTerm :: (TTerm a)} - deriving (Eq, Ord, Read, Show) - -_TBinding = Core.Name "hydra.phantoms.TBinding" - -_TBinding_name = Core.Name "name" - -_TBinding_term = Core.Name "term" - --- | An association of a term with a phantom type -newtype TTerm a = - TTerm { - unTTerm :: Core.Term} - deriving (Eq, Ord, Read, Show) - -_TTerm = Core.Name "hydra.phantoms.TTerm" diff --git a/src/gen-main/haskell/Hydra/Query.hs b/src/gen-main/haskell/Hydra/Query.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Query.hs +++ /dev/null @@ -1,287 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | A model for language-agnostic graph pattern queries - -module Hydra.Query where - -import qualified Hydra.Core as Core -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | One of several comparison operators -data ComparisonConstraint = - ComparisonConstraintEqual | - ComparisonConstraintNotEqual | - ComparisonConstraintLessThan | - ComparisonConstraintGreaterThan | - ComparisonConstraintLessThanOrEqual | - ComparisonConstraintGreaterThanOrEqual - deriving (Eq, Ord, Read, Show) - -_ComparisonConstraint = Core.Name "hydra.query.ComparisonConstraint" - -_ComparisonConstraint_equal = Core.Name "equal" - -_ComparisonConstraint_notEqual = Core.Name "notEqual" - -_ComparisonConstraint_lessThan = Core.Name "lessThan" - -_ComparisonConstraint_greaterThan = Core.Name "greaterThan" - -_ComparisonConstraint_lessThanOrEqual = Core.Name "lessThanOrEqual" - -_ComparisonConstraint_greaterThanOrEqual = Core.Name "greaterThanOrEqual" - --- | An abstract edge based on a record type -data Edge = - Edge { - -- | The name of a record type, for which the edge also specifies an out- and an in- projection - edgeType :: Core.Name, - -- | The field representing the out-projection of the edge. Defaults to 'out'. - edgeOut :: (Maybe Core.Name), - -- | The field representing the in-projection of the edge. Defaults to 'in'. - edgeIn :: (Maybe Core.Name)} - deriving (Eq, Ord, Read, Show) - -_Edge = Core.Name "hydra.query.Edge" - -_Edge_type = Core.Name "type" - -_Edge_out = Core.Name "out" - -_Edge_in = Core.Name "in" - --- | A query pattern which matches within a designated component subgraph -data GraphPattern = - GraphPattern { - -- | The name of the component graph - graphPatternGraph :: Core.Name, - -- | The patterns to match within the subgraph - graphPatternPatterns :: [Pattern]} - deriving (Eq, Ord, Read, Show) - -_GraphPattern = Core.Name "hydra.query.GraphPattern" - -_GraphPattern_graph = Core.Name "graph" - -_GraphPattern_patterns = Core.Name "patterns" - --- | A node in a query expression; it may be a term, a variable, or a wildcard -data Node = - -- | A graph term; an expression which is valid in the graph being matched - NodeTerm Core.Term | - -- | A query variable, not to be confused with a variable term - NodeVariable Variable | - -- | An anonymous variable which we do not care to join across patterns - NodeWildcard - deriving (Eq, Ord, Read, Show) - -_Node = Core.Name "hydra.query.Node" - -_Node_term = Core.Name "term" - -_Node_variable = Core.Name "variable" - -_Node_wildcard = Core.Name "wildcard" - --- | A query path -data Path = - -- | A path given by a single step - PathStep Step | - -- | A path given by a regular expression quantifier applied to another path - PathRegex RegexSequence | - -- | A path given by the inverse of another path - PathInverse Path - deriving (Eq, Ord, Read, Show) - -_Path = Core.Name "hydra.query.Path" - -_Path_step = Core.Name "step" - -_Path_regex = Core.Name "regex" - -_Path_inverse = Core.Name "inverse" - --- | A declared equivalence between two abstract paths in a graph -data PathEquation = - PathEquation { - -- | The left-hand side of the equation - pathEquationLeft :: Path, - -- | The right-hand side of the equation - pathEquationRight :: Path} - deriving (Eq, Ord, Read, Show) - -_PathEquation = Core.Name "hydra.query.PathEquation" - -_PathEquation_left = Core.Name "left" - -_PathEquation_right = Core.Name "right" - --- | A query pattern -data Pattern = - -- | A subject/predicate/object pattern - PatternTriple TriplePattern | - -- | The negation of another pattern - PatternNegation Pattern | - -- | The conjunction ('and') of several other patterns - PatternConjunction [Pattern] | - -- | The disjunction (inclusive 'or') of several other patterns - PatternDisjunction [Pattern] | - -- | A pattern which matches within a named subgraph - PatternGraph GraphPattern - deriving (Eq, Ord, Read, Show) - -_Pattern = Core.Name "hydra.query.Pattern" - -_Pattern_triple = Core.Name "triple" - -_Pattern_negation = Core.Name "negation" - -_Pattern_conjunction = Core.Name "conjunction" - -_Pattern_disjunction = Core.Name "disjunction" - -_Pattern_graph = Core.Name "graph" - --- | A pattern which, if it matches in a given graph, implies that another pattern must also match. Query variables are shared between the two patterns. -data PatternImplication = - PatternImplication { - -- | The pattern which, if it matches, triggers the constraint - patternImplicationAntecedent :: Pattern, - -- | The pattern which must also match when the antecedent matches - patternImplicationConsequent :: Pattern} - deriving (Eq, Ord, Read, Show) - -_PatternImplication = Core.Name "hydra.query.PatternImplication" - -_PatternImplication_antecedent = Core.Name "antecedent" - -_PatternImplication_consequent = Core.Name "consequent" - --- | A SELECT-style graph pattern matching query -data Query = - Query { - -- | The variables selected by the query - queryVariables :: [Variable], - -- | The patterns to be matched - queryPatterns :: [Pattern]} - deriving (Eq, Ord, Read, Show) - -_Query = Core.Name "hydra.query.Query" - -_Query_variables = Core.Name "variables" - -_Query_patterns = Core.Name "patterns" - --- | A range from min to max, inclusive -data Range = - Range { - -- | The minimum value (inclusive) - rangeMin :: Int, - -- | The maximum value (inclusive) - rangeMax :: Int} - deriving (Eq, Ord, Read, Show) - -_Range = Core.Name "hydra.query.Range" - -_Range_min = Core.Name "min" - -_Range_max = Core.Name "max" - --- | A regular expression quantifier -data RegexQuantifier = - -- | No quantifier; matches a single occurrence - RegexQuantifierOne | - -- | The ? quanifier; matches zero or one occurrence - RegexQuantifierZeroOrOne | - -- | The * quantifier; matches any number of occurrences - RegexQuantifierZeroOrMore | - -- | The + quantifier; matches one or more occurrences - RegexQuantifierOneOrMore | - -- | The {n} quantifier; matches exactly n occurrences - RegexQuantifierExactly Int | - -- | The {n,} quantifier; matches at least n occurrences - RegexQuantifierAtLeast Int | - -- | The {n, m} quantifier; matches between n and m (inclusive) occurrences - RegexQuantifierRange Range - deriving (Eq, Ord, Read, Show) - -_RegexQuantifier = Core.Name "hydra.query.RegexQuantifier" - -_RegexQuantifier_one = Core.Name "one" - -_RegexQuantifier_zeroOrOne = Core.Name "zeroOrOne" - -_RegexQuantifier_zeroOrMore = Core.Name "zeroOrMore" - -_RegexQuantifier_oneOrMore = Core.Name "oneOrMore" - -_RegexQuantifier_exactly = Core.Name "exactly" - -_RegexQuantifier_atLeast = Core.Name "atLeast" - -_RegexQuantifier_range = Core.Name "range" - --- | A path with a regex quantifier -data RegexSequence = - RegexSequence { - -- | The path to which the quantifier applies - regexSequencePath :: Path, - -- | The quantifier - regexSequenceQuantifier :: RegexQuantifier} - deriving (Eq, Ord, Read, Show) - -_RegexSequence = Core.Name "hydra.query.RegexSequence" - -_RegexSequence_path = Core.Name "path" - -_RegexSequence_quantifier = Core.Name "quantifier" - --- | An atomic function as part of a query. When applied to a graph, steps are typed by function types. -data Step = - -- | An out-to-in traversal of an abstract edge - StepEdge Edge | - -- | A projection from a record through one of its fields - StepProject Core.Projection | - -- | A comparison of two terms - StepCompare ComparisonConstraint - deriving (Eq, Ord, Read, Show) - -_Step = Core.Name "hydra.query.Step" - -_Step_edge = Core.Name "edge" - -_Step_project = Core.Name "project" - -_Step_compare = Core.Name "compare" - --- | A subject/predicate/object pattern -data TriplePattern = - TriplePattern { - -- | The subject of the pattern - triplePatternSubject :: Node, - -- | The predicate (property) of the pattern - triplePatternPredicate :: Path, - -- | The object of the pattern - triplePatternObject :: Node} - deriving (Eq, Ord, Read, Show) - -_TriplePattern = Core.Name "hydra.query.TriplePattern" - -_TriplePattern_subject = Core.Name "subject" - -_TriplePattern_predicate = Core.Name "predicate" - -_TriplePattern_object = Core.Name "object" - --- | A query variable -newtype Variable = - Variable { - unVariable :: String} - deriving (Eq, Ord, Read, Show) - -_Variable = Core.Name "hydra.query.Variable" diff --git a/src/gen-main/haskell/Hydra/Reduction.hs b/src/gen-main/haskell/Hydra/Reduction.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Reduction.hs +++ /dev/null @@ -1,622 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Functions for reducing terms and types, i.e. performing computations. - -module Hydra.Reduction where - -import qualified Hydra.Arity as Arity -import qualified Hydra.Checking as Checking -import qualified Hydra.Context as Context -import qualified Hydra.Core as Core -import qualified Hydra.Encode.Core as Core_ -import qualified Hydra.Errors as Errors -import qualified Hydra.Extract.Core as Core__ -import qualified Hydra.Graph as Graph -import qualified Hydra.Lexical as Lexical -import qualified Hydra.Lib.Eithers as Eithers -import qualified Hydra.Lib.Equality as Equality -import qualified Hydra.Lib.Lists as Lists -import qualified Hydra.Lib.Literals as Literals -import qualified Hydra.Lib.Logic as Logic -import qualified Hydra.Lib.Maps as Maps -import qualified Hydra.Lib.Math as Math -import qualified Hydra.Lib.Maybes as Maybes -import qualified Hydra.Lib.Pairs as Pairs -import qualified Hydra.Lib.Sets as Sets -import qualified Hydra.Lib.Strings as Strings -import qualified Hydra.Rewriting as Rewriting -import qualified Hydra.Schemas as Schemas -import qualified Hydra.Show.Errors as Errors_ -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | Alpha convert a variable in a term -alphaConvert :: Core.Name -> Core.Name -> Core.Term -> Core.Term -alphaConvert vold vnew term = Rewriting.replaceFreeTermVariable vold (Core.TermVariable vnew) term - --- | Eagerly beta-reduce a type by substituting type arguments into type lambdas -betaReduceType :: Context.Context -> Graph.Graph -> Core.Type -> Either (Context.InContext Errors.Error) Core.Type -betaReduceType cx graph typ = - - let reduceApp = - \app -> - let lhs = Core.applicationTypeFunction app - rhs = Core.applicationTypeArgument app - in case lhs of - Core.TypeAnnotated v0 -> Eithers.bind (reduceApp (Core.ApplicationType { - Core.applicationTypeFunction = (Core.annotatedTypeBody v0), - Core.applicationTypeArgument = rhs})) (\a -> Right (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = a, - Core.annotatedTypeAnnotation = (Core.annotatedTypeAnnotation v0)}))) - Core.TypeForall v0 -> betaReduceType cx graph (Rewriting.replaceFreeTypeVariable (Core.forallTypeParameter v0) rhs (Core.forallTypeBody v0)) - Core.TypeVariable v0 -> Eithers.bind (Schemas.requireType cx graph v0) (\t_ -> betaReduceType cx graph (Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = t_, - Core.applicationTypeArgument = rhs}))) - mapExpr = - \recurse -> \t -> - let findApp = - \r -> case r of - Core.TypeApplication v0 -> reduceApp v0 - _ -> Right r - in (Eithers.bind (recurse t) (\r -> findApp r)) - in (Rewriting.rewriteTypeM mapExpr typ) - --- | Apply the special rules: --- | ((\x.e1) e2) == e1, where x does not appear free in e1 --- | and --- | ((\x.e1) e2) = e1[x/e2] --- | These are both limited forms of beta reduction which help to "clean up" a term without fully evaluating it. -contractTerm :: Core.Term -> Core.Term -contractTerm term = - - let rewrite = - \recurse -> \t -> - let rec = recurse t - in case rec of - Core.TermApplication v0 -> - let lhs = Core.applicationFunction v0 - rhs = Core.applicationArgument v0 - in case (Rewriting.deannotateTerm lhs) of - Core.TermFunction v1 -> case v1 of - Core.FunctionLambda v2 -> - let v = Core.lambdaParameter v2 - body = Core.lambdaBody v2 - in (Logic.ifElse (Rewriting.isFreeVariableInTerm v body) body (Rewriting.replaceFreeTermVariable v rhs body)) - _ -> rec - _ -> rec - _ -> rec - in (Rewriting.rewriteTerm rewrite term) - -countPrimitiveInvocations :: Bool -countPrimitiveInvocations = True - --- | Recursively transform arbitrary terms like 'add 42' into terms like '\x.add 42 x', in which the implicit parameters of primitive functions and eliminations are made into explicit lambda parameters. Variable references are not expanded. This is useful for targets like Python with weaker support for currying than Hydra or Haskell. Note: this is a "trusty" function which assumes the graph is well-formed, i.e. no dangling references. -etaExpandTerm :: Graph.Graph -> Core.Term -> Core.Term -etaExpandTerm graph term = - - let expand = - \args -> \arity -> \t -> - let apps = - Lists.foldl (\lhs -> \arg -> Core.TermApplication (Core.Application { - Core.applicationFunction = lhs, - Core.applicationArgument = arg})) t args - is = Logic.ifElse (Equality.lte arity (Lists.length args)) [] (Math.range 1 (Math.sub arity (Lists.length args))) - pad = - \indices -> \t -> Logic.ifElse (Lists.null indices) t (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name (Strings.cat2 "v" (Literals.showInt32 (Lists.head indices)))), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (pad (Lists.tail indices) (Core.TermApplication (Core.Application { - Core.applicationFunction = t, - Core.applicationArgument = (Core.TermVariable (Core.Name (Strings.cat2 "v" (Literals.showInt32 (Lists.head indices)))))})))}))) - in (pad is apps) - rewrite = - \args -> \recurse -> \t -> - let afterRecursion = \term -> expand args (etaExpansionArity graph term) term - t2 = Rewriting.detypeTerm t - in case t2 of - Core.TermApplication v0 -> - let lhs = Core.applicationFunction v0 - rhs = Core.applicationArgument v0 - erhs = rewrite [] recurse rhs - in (rewrite (Lists.cons erhs args) recurse lhs) - _ -> afterRecursion (recurse t2) - in (contractTerm (Rewriting.rewriteTerm (rewrite []) term)) - --- | Recursively transform terms to eliminate partial application, e.g. 'add 42' becomes '\x.add 42 x'. Uses the Graph to look up types for arity calculation. Bare primitives and variables are NOT expanded; eliminations and partial applications are. This version properly tracks the Graph through nested scopes. -etaExpandTermNew :: Graph.Graph -> Core.Term -> Core.Term -etaExpandTermNew tx0 term0 = - - let primTypes = - Maps.fromList (Lists.map (\_gpt_p -> (Graph.primitiveName _gpt_p, (Graph.primitiveType _gpt_p))) (Maps.elems (Graph.graphPrimitives tx0))) - termArityWithContext = - \tx -> \term -> case term of - Core.TermAnnotated v0 -> termArityWithContext tx (Core.annotatedTermBody v0) - Core.TermApplication v0 -> Math.sub (termArityWithContext tx (Core.applicationFunction v0)) 1 - Core.TermFunction v0 -> case v0 of - Core.FunctionElimination _ -> 1 - Core.FunctionLambda _ -> 0 - Core.FunctionPrimitive v1 -> Maybes.maybe 0 Arity.typeSchemeArity (Maps.lookup v1 primTypes) - Core.TermLet v0 -> termArityWithContext (Rewriting.extendGraphForLet (\_ -> \_ -> Nothing) tx v0) (Core.letBody v0) - Core.TermTypeLambda v0 -> termArityWithContext (Rewriting.extendGraphForTypeLambda tx v0) (Core.typeLambdaBody v0) - Core.TermTypeApplication v0 -> termArityWithContext tx (Core.typeApplicationTermBody v0) - Core.TermVariable v0 -> Maybes.maybe 0 Arity.typeArity (Maybes.map Rewriting.typeSchemeToFType (Maps.lookup v0 (Graph.graphBoundTypes tx))) - _ -> 0 - domainTypes = - \n -> \mt -> Logic.ifElse (Equality.lte n 0) [] (Maybes.maybe (Lists.map (\_ -> Nothing) (Math.range 1 n)) (\typ -> case typ of - Core.TypeFunction v0 -> Lists.cons (Just (Core.functionTypeDomain v0)) (domainTypes (Math.sub n 1) (Just (Core.functionTypeCodomain v0))) - Core.TypeAnnotated v0 -> domainTypes n (Just (Core.annotatedTypeBody v0)) - Core.TypeApplication v0 -> domainTypes n (Just (Core.applicationTypeFunction v0)) - Core.TypeForall _ -> Lists.map (\_ -> Nothing) (Math.range 1 n) - _ -> Lists.map (\_ -> Nothing) (Math.range 1 n)) mt) - peelFunctionDomains = - \mtyp -> \n -> Logic.ifElse (Equality.lte n 0) mtyp (Maybes.maybe Nothing (\typ -> case typ of - Core.TypeFunction v0 -> peelFunctionDomains (Just (Core.functionTypeCodomain v0)) (Math.sub n 1) - Core.TypeAnnotated v0 -> peelFunctionDomains (Just (Core.annotatedTypeBody v0)) n - Core.TypeApplication v0 -> peelFunctionDomains (Just (Core.applicationTypeFunction v0)) n - Core.TypeForall _ -> Nothing - _ -> Nothing) mtyp) - expand = - \alwaysPad -> \args -> \arity -> \headTyp -> \head -> - let applied = - Lists.foldl (\lhs -> \arg -> Core.TermApplication (Core.Application { - Core.applicationFunction = lhs, - Core.applicationArgument = arg})) head args - numArgs = Lists.length args - needed = Math.sub arity numArgs - in (Logic.ifElse (Logic.and (Equality.gt needed 0) (Logic.or alwaysPad (Equality.gt numArgs 0))) ( - let indices = Math.range 1 needed - remainingType = peelFunctionDomains headTyp numArgs - domains = domainTypes needed remainingType - codomainType = peelFunctionDomains remainingType needed - fullyAppliedRaw = - Lists.foldl (\body -> \i -> - let vn = Core.Name (Strings.cat2 "v" (Literals.showInt32 i)) - in (Core.TermApplication (Core.Application { - Core.applicationFunction = body, - Core.applicationArgument = (Core.TermVariable vn)}))) applied indices - fullyApplied = - Maybes.maybe fullyAppliedRaw (\ct -> Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = fullyAppliedRaw, - Core.annotatedTermAnnotation = (Maps.singleton (Core.Name "type") (Core_.type_ ct))})) codomainType - indexedDomains = Lists.zip indices domains - in (Lists.foldl (\body -> \idPair -> - let i = Pairs.first idPair - dom = Pairs.second idPair - vn = Core.Name (Strings.cat2 "v" (Literals.showInt32 i)) - in (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = vn, - Core.lambdaDomain = dom, - Core.lambdaBody = body})))) fullyApplied (Lists.reverse indexedDomains))) applied) - rewriteWithArgs = - \args -> \tx -> \term -> - let recurse = \tx1 -> \term1 -> rewriteWithArgs [] tx1 term1 - termHeadType = - \tx2 -> \trm2 -> case trm2 of - Core.TermAnnotated v0 -> termHeadType tx2 (Core.annotatedTermBody v0) - Core.TermFunction v0 -> case v0 of - Core.FunctionPrimitive v1 -> Maybes.map Rewriting.typeSchemeToFType (Maps.lookup v1 primTypes) - _ -> Nothing - Core.TermLet v0 -> termHeadType (Rewriting.extendGraphForLet (\_ -> \_ -> Nothing) tx2 v0) (Core.letBody v0) - Core.TermTypeLambda v0 -> termHeadType (Rewriting.extendGraphForTypeLambda tx2 v0) (Core.typeLambdaBody v0) - Core.TermTypeApplication v0 -> Maybes.bind (termHeadType tx2 (Core.typeApplicationTermBody v0)) (\htyp2 -> case htyp2 of - Core.TypeForall v1 -> Just (Rewriting.replaceFreeTypeVariable (Core.forallTypeParameter v1) (Core.typeApplicationTermType v0) (Core.forallTypeBody v1)) - _ -> Just htyp2) - Core.TermVariable v0 -> Maybes.map Rewriting.typeSchemeToFType (Maps.lookup v0 (Graph.graphBoundTypes tx2)) - _ -> Nothing - afterRecursion = - \trm -> - let arity = termArityWithContext tx trm - hType = termHeadType tx trm - in (expand False args arity hType trm) - forField = - \f -> Core.Field { - Core.fieldName = (Core.fieldName f), - Core.fieldTerm = (recurse tx (Core.fieldTerm f))} - forCaseBranch = - \f -> - let branchBody = recurse tx (Core.fieldTerm f) - arty = termArityWithContext tx branchBody - branchHType = termHeadType tx branchBody - in Core.Field { - Core.fieldName = (Core.fieldName f), - Core.fieldTerm = (expand True [] arty branchHType branchBody)} - forElimination = - \elm -> case elm of - Core.EliminationRecord v0 -> Core.EliminationRecord v0 - Core.EliminationUnion v0 -> Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.caseStatementTypeName v0), - Core.caseStatementDefault = (Maybes.map (\t1 -> recurse tx t1) (Core.caseStatementDefault v0)), - Core.caseStatementCases = (Lists.map forCaseBranch (Core.caseStatementCases v0))}) - Core.EliminationWrap v0 -> Core.EliminationWrap v0 - forMap = - \mp -> - let forPair = \pr -> (recurse tx (Pairs.first pr), (recurse tx (Pairs.second pr))) - in (Maps.fromList (Lists.map forPair (Maps.toList mp))) - in case term of - Core.TermAnnotated v0 -> afterRecursion (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (recurse tx (Core.annotatedTermBody v0)), - Core.annotatedTermAnnotation = (Core.annotatedTermAnnotation v0)})) - Core.TermApplication v0 -> - let rhs = rewriteWithArgs [] tx (Core.applicationArgument v0) - in (rewriteWithArgs (Lists.cons rhs args) tx (Core.applicationFunction v0)) - Core.TermEither v0 -> afterRecursion (Core.TermEither (Eithers.either (\l -> Left (recurse tx l)) (\r -> Right (recurse tx r)) v0)) - Core.TermFunction v0 -> case v0 of - Core.FunctionElimination v1 -> - let padElim = - case v1 of - Core.EliminationRecord _ -> False - Core.EliminationUnion _ -> True - Core.EliminationWrap _ -> False - elimTerm = Core.TermFunction (Core.FunctionElimination (forElimination v1)) - elimHeadType = - case v1 of - Core.EliminationUnion v2 -> Just (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.caseStatementTypeName v2)), - Core.functionTypeCodomain = Core.TypeUnit})) - _ -> Nothing - in (expand padElim args 1 elimHeadType elimTerm) - Core.FunctionLambda v1 -> - let tx1 = Rewriting.extendGraphForLambda tx v1 - body = rewriteWithArgs [] tx1 (Core.lambdaBody v1) - result = - Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.lambdaParameter v1), - Core.lambdaDomain = (Core.lambdaDomain v1), - Core.lambdaBody = body})) - arty = termArityWithContext tx result - in (expand False args arty Nothing result) - Core.FunctionPrimitive v1 -> - let arty = termArityWithContext tx term - primType = Maybes.map (\ts -> Core.typeSchemeType ts) (Maps.lookup v1 primTypes) - in (expand False args arty primType term) - Core.TermLet v0 -> - let tx1 = Rewriting.extendGraphForLet (\_ -> \_ -> Nothing) tx v0 - mapBinding = - \b -> Core.Binding { - Core.bindingName = (Core.bindingName b), - Core.bindingTerm = (rewriteWithArgs [] tx1 (Core.bindingTerm b)), - Core.bindingType = (Core.bindingType b)} - result = - Core.TermLet (Core.Let { - Core.letBindings = (Lists.map mapBinding (Core.letBindings v0)), - Core.letBody = (rewriteWithArgs [] tx1 (Core.letBody v0))}) - in (afterRecursion result) - Core.TermList v0 -> afterRecursion (Core.TermList (Lists.map (\el -> recurse tx el) v0)) - Core.TermLiteral v0 -> Core.TermLiteral v0 - Core.TermMap v0 -> afterRecursion (Core.TermMap (forMap v0)) - Core.TermMaybe v0 -> afterRecursion (Core.TermMaybe (Maybes.map (\v -> recurse tx v) v0)) - Core.TermPair v0 -> afterRecursion (Core.TermPair (recurse tx (Pairs.first v0), (recurse tx (Pairs.second v0)))) - Core.TermRecord v0 -> afterRecursion (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.recordTypeName v0), - Core.recordFields = (Lists.map forField (Core.recordFields v0))})) - Core.TermSet v0 -> afterRecursion (Core.TermSet (Sets.fromList (Lists.map (\el -> recurse tx el) (Sets.toList v0)))) - Core.TermTypeApplication v0 -> afterRecursion (Core.TermTypeApplication (Core.TypeApplicationTerm { - Core.typeApplicationTermBody = (recurse tx (Core.typeApplicationTermBody v0)), - Core.typeApplicationTermType = (Core.typeApplicationTermType v0)})) - Core.TermTypeLambda v0 -> - let tx1 = Rewriting.extendGraphForTypeLambda tx v0 - result = - Core.TermTypeLambda (Core.TypeLambda { - Core.typeLambdaParameter = (Core.typeLambdaParameter v0), - Core.typeLambdaBody = (rewriteWithArgs [] tx1 (Core.typeLambdaBody v0))}) - in (afterRecursion result) - Core.TermUnion v0 -> afterRecursion (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.injectionTypeName v0), - Core.injectionField = (forField (Core.injectionField v0))})) - Core.TermUnit -> Core.TermUnit - Core.TermVariable v0 -> - let arty = termArityWithContext tx term - varType = Maybes.map Rewriting.typeSchemeToFType (Maps.lookup v0 (Graph.graphBoundTypes tx)) - in (expand False args arty varType term) - Core.TermWrap v0 -> afterRecursion (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.wrappedTermTypeName v0), - Core.wrappedTermBody = (recurse tx (Core.wrappedTermBody v0))})) - in (contractTerm (rewriteWithArgs [] tx0 term0)) - --- | Recursively transform arbitrary terms like 'add 42' into terms like '\x.add 42 x', eliminating partial application. Variable references are not expanded. This is useful for targets like Python with weaker support for currying than Hydra or Haskell. Note: this is a "trusty" function which assumes the graph is well-formed, i.e. no dangling references. It also assumes that type inference has already been performed. After eta expansion, type inference needs to be performed again, as new, untyped lambdas may have been added. -etaExpandTypedTerm :: Context.Context -> Graph.Graph -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -etaExpandTypedTerm cx tx0 term0 = - - let rewrite = - \topLevel -> \forced -> \typeArgs -> \recurse -> \tx -> \term -> - let rewriteSpine = - \term -> case term of - Core.TermAnnotated v0 -> Eithers.bind (rewriteSpine (Core.annotatedTermBody v0)) (\body -> - let ann = Core.annotatedTermAnnotation v0 - in (Right (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = body, - Core.annotatedTermAnnotation = ann})))) - Core.TermApplication v0 -> - let l = Logic.ifElse False [ - Core.TypeLiteral Core.LiteralTypeString] [] - in (Eithers.bind (rewriteSpine (Core.applicationFunction v0)) (\lhs -> Eithers.bind (rewrite True False l recurse tx (Core.applicationArgument v0)) (\rhs -> Right (Core.TermApplication (Core.Application { - Core.applicationFunction = lhs, - Core.applicationArgument = rhs}))))) - Core.TermTypeApplication v0 -> Eithers.bind (rewriteSpine (Core.typeApplicationTermBody v0)) (\body -> - let typ = Core.typeApplicationTermType v0 - in (Right (Core.TermTypeApplication (Core.TypeApplicationTerm { - Core.typeApplicationTermBody = body, - Core.typeApplicationTermType = typ})))) - _ -> rewrite False False [] recurse tx term - arityOf = - \tx -> \term -> - let dflt = Eithers.map (\_tc -> Arity.typeArity (Pairs.first _tc)) (Checking.typeOf cx tx [] term) - forFunction = - \tx -> \f -> case f of - Core.FunctionElimination _ -> Right 1 - Core.FunctionLambda v0 -> - let txl = Rewriting.extendGraphForLambda tx v0 - in (arityOf txl (Core.lambdaBody v0)) - Core.FunctionPrimitive v0 -> Eithers.map (\_ts -> Arity.typeSchemeArity _ts) (Lexical.requirePrimitiveType cx tx v0) - in case term of - Core.TermAnnotated v0 -> arityOf tx (Core.annotatedTermBody v0) - Core.TermFunction v0 -> forFunction tx v0 - Core.TermLet v0 -> - let txl = Rewriting.extendGraphForLet (\_ -> \_ -> Nothing) tx v0 - in (arityOf txl (Core.letBody v0)) - Core.TermTypeApplication v0 -> arityOf tx (Core.typeApplicationTermBody v0) - Core.TermTypeLambda v0 -> - let txt = Rewriting.extendGraphForTypeLambda tx v0 - in (arityOf txt (Core.typeLambdaBody v0)) - Core.TermVariable v0 -> Maybes.maybe (Eithers.map (\_tc -> Arity.typeArity (Pairs.first _tc)) (Checking.typeOf cx tx [] (Core.TermVariable v0))) (\t -> Right (Arity.typeArity t)) (Maybes.map Rewriting.typeSchemeToFType (Maps.lookup v0 (Graph.graphBoundTypes tx))) - _ -> dflt - extraVariables = \n -> Lists.map (\i -> Core.Name (Strings.cat2 "v" (Literals.showInt32 i))) (Math.range 1 n) - pad = - \vars -> \body -> Logic.ifElse (Lists.null vars) body (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Lists.head vars), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (pad (Lists.tail vars) (Core.TermApplication (Core.Application { - Core.applicationFunction = body, - Core.applicationArgument = (Core.TermVariable (Lists.head vars))})))}))) - padn = \n -> \body -> pad (extraVariables n) body - unwind = - \term -> Lists.foldl (\e -> \t -> Core.TermTypeApplication (Core.TypeApplicationTerm { - Core.typeApplicationTermBody = e, - Core.typeApplicationTermType = t})) term typeArgs - forceExpansion = - \t -> Eithers.bind (Checking.typeOf cx tx [] t) (\typCx -> - let arity = Arity.typeArity (Pairs.first typCx) - in (Right (padn arity (unwind t)))) - recurseOrForce = \term -> Logic.ifElse forced (forceExpansion term) (recurse tx (unwind term)) - forCase = - \f -> Eithers.bind (rewrite False True [] recurse tx (Core.fieldTerm f)) (\r -> Right (Core.Field { - Core.fieldName = (Core.fieldName f), - Core.fieldTerm = r})) - forCaseStatement = - \cs -> - let tname = Core.caseStatementTypeName cs - dflt = Core.caseStatementDefault cs - cases = Core.caseStatementCases cs - in (Eithers.bind (Eithers.mapMaybe (rewrite False False [] recurse tx) dflt) (\rdflt -> Eithers.bind (Eithers.mapList forCase cases) (\rcases -> Right (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = tname, - Core.caseStatementDefault = rdflt, - Core.caseStatementCases = rcases}))))))) - forElimination = - \elm -> - let checkBase = - \elm -> case elm of - Core.EliminationUnion v0 -> forCaseStatement v0 - _ -> recurse tx term - in (Eithers.bind (Eithers.map unwind (checkBase elm)) (\base -> Right (Logic.ifElse (Logic.or topLevel forced) (padn 1 base) base))) - in case term of - Core.TermApplication v0 -> - let lhs = Core.applicationFunction v0 - rhs = Core.applicationArgument v0 - in (Eithers.bind (rewrite True False [] recurse tx rhs) (\rhs2 -> Eithers.bind (arityOf tx lhs) (\lhsarity -> Eithers.bind (rewriteSpine lhs) (\lhs2 -> - let a2 = - Core.TermApplication (Core.Application { - Core.applicationFunction = lhs2, - Core.applicationArgument = rhs2}) - in (Right (Logic.ifElse (Equality.gt lhsarity 1) (padn (Math.sub lhsarity 1) a2) a2)))))) - Core.TermFunction v0 -> case v0 of - Core.FunctionElimination v1 -> forElimination v1 - Core.FunctionLambda v1 -> - let txl = Rewriting.extendGraphForLambda tx v1 - in (Eithers.map unwind (recurse txl term)) - _ -> recurseOrForce term - Core.TermLet v0 -> - let txlt = Rewriting.extendGraphForLet (\_ -> \_ -> Nothing) tx v0 - in (recurse txlt term) - Core.TermTypeApplication v0 -> rewrite topLevel forced (Lists.cons (Core.typeApplicationTermType v0) typeArgs) recurse tx (Core.typeApplicationTermBody v0) - Core.TermTypeLambda v0 -> - let txt = Rewriting.extendGraphForTypeLambda tx v0 - in (recurse txt term) - _ -> recurseOrForce term - in (Rewriting.rewriteTermWithContextM (rewrite True False []) tx0 term0) - --- | Calculate the arity for eta expansion Note: this is a "trusty" function which assumes the graph is well-formed, i.e. no dangling references. -etaExpansionArity :: Graph.Graph -> Core.Term -> Int -etaExpansionArity graph term = - case term of - Core.TermAnnotated v0 -> etaExpansionArity graph (Core.annotatedTermBody v0) - Core.TermApplication v0 -> Math.sub (etaExpansionArity graph (Core.applicationFunction v0)) 1 - Core.TermFunction v0 -> case v0 of - Core.FunctionElimination _ -> 1 - Core.FunctionLambda _ -> 0 - Core.FunctionPrimitive v1 -> Arity.primitiveArity (Maybes.fromJust (Lexical.lookupPrimitive graph v1)) - Core.TermTypeLambda v0 -> etaExpansionArity graph (Core.typeLambdaBody v0) - Core.TermTypeApplication v0 -> etaExpansionArity graph (Core.typeApplicationTermBody v0) - Core.TermVariable v0 -> Maybes.maybe 0 (\ts -> Arity.typeArity (Core.typeSchemeType ts)) (Maybes.bind (Lexical.lookupElement graph v0) (\b -> Core.bindingType b)) - _ -> 0 - --- | Eta-reduce a term by removing redundant lambda abstractions -etaReduceTerm :: Core.Term -> Core.Term -etaReduceTerm term = - - let noChange = term - reduceLambda = - \l -> - let v = Core.lambdaParameter l - d = Core.lambdaDomain l - body = Core.lambdaBody l - in case (etaReduceTerm body) of - Core.TermAnnotated v0 -> reduceLambda (Core.Lambda { - Core.lambdaParameter = v, - Core.lambdaDomain = d, - Core.lambdaBody = (Core.annotatedTermBody v0)}) - Core.TermApplication v0 -> - let lhs = Core.applicationFunction v0 - rhs = Core.applicationArgument v0 - in case (etaReduceTerm rhs) of - Core.TermAnnotated v1 -> reduceLambda (Core.Lambda { - Core.lambdaParameter = v, - Core.lambdaDomain = d, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = lhs, - Core.applicationArgument = (Core.annotatedTermBody v1)}))}) - Core.TermVariable v1 -> Logic.ifElse (Logic.and (Equality.equal (Core.unName v) (Core.unName v1)) (Logic.not (Rewriting.isFreeVariableInTerm v lhs))) (etaReduceTerm lhs) noChange - _ -> noChange - _ -> noChange - in case term of - Core.TermAnnotated v0 -> Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (etaReduceTerm (Core.annotatedTermBody v0)), - Core.annotatedTermAnnotation = (Core.annotatedTermAnnotation v0)}) - Core.TermFunction v0 -> case v0 of - Core.FunctionLambda v1 -> reduceLambda v1 - _ -> noChange - _ -> noChange - --- | A term evaluation function which is alternatively lazy or eager -reduceTerm :: Context.Context -> Graph.Graph -> Bool -> Core.Term -> Either (Context.InContext Errors.Error) Core.Term -reduceTerm cx graph eager term = - - let reduce = \eager -> reduceTerm cx graph eager - doRecurse = - \eager -> \term -> - let isNonLambda = - \f -> case f of - Core.FunctionLambda _ -> False - _ -> True - isNonLambdaTerm = - case term of - Core.TermFunction v0 -> isNonLambda v0 - Core.TermLet _ -> False - _ -> True - in (Logic.and eager isNonLambdaTerm) - reduceArg = \eager -> \arg -> Logic.ifElse eager (Right arg) (reduce False arg) - applyToArguments = - \fun -> \args -> Logic.ifElse (Lists.null args) fun (applyToArguments (Core.TermApplication (Core.Application { - Core.applicationFunction = fun, - Core.applicationArgument = (Lists.head args)})) (Lists.tail args)) - mapErrorToString = - \ic -> Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Errors_.error (Context.inContextObject ic)))), - Context.inContextContext = (Context.inContextContext ic)} - applyElimination = - \elm -> \reducedArg -> case elm of - Core.EliminationRecord v0 -> Eithers.bind (Core__.record cx (Core.projectionTypeName v0) graph (Rewriting.deannotateTerm reducedArg)) (\fields -> - let matchingFields = Lists.filter (\f -> Equality.equal (Core.fieldName f) (Core.projectionField v0)) fields - in (Logic.ifElse (Lists.null matchingFields) (Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat [ - "no such field: ", - (Core.unName (Core.projectionField v0)), - " in ", - (Core.unName (Core.projectionTypeName v0)), - " record"]))), - Context.inContextContext = cx})) (Right (Core.fieldTerm (Lists.head matchingFields))))) - Core.EliminationUnion v0 -> Eithers.bind (Core__.injection cx (Core.caseStatementTypeName v0) graph reducedArg) (\field -> - let matchingFields = Lists.filter (\f -> Equality.equal (Core.fieldName f) (Core.fieldName field)) (Core.caseStatementCases v0) - in (Logic.ifElse (Lists.null matchingFields) (Maybes.maybe (Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat [ - "no such field ", - (Core.unName (Core.fieldName field)), - " in ", - (Core.unName (Core.caseStatementTypeName v0)), - " case statement"]))), - Context.inContextContext = cx})) (\x -> Right x) (Core.caseStatementDefault v0)) (Right (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.fieldTerm (Lists.head matchingFields)), - Core.applicationArgument = (Core.fieldTerm field)}))))) - Core.EliminationWrap v0 -> Core__.wrap cx v0 graph reducedArg - applyIfNullary = - \eager -> \original -> \args -> - let stripped = Rewriting.deannotateTerm original - forElimination = - \elm -> \args -> - let arg = Lists.head args - remainingArgs = Lists.tail args - in (Eithers.bind (reduceArg eager (Rewriting.deannotateTerm arg)) (\reducedArg -> Eithers.bind (Eithers.bind (applyElimination elm reducedArg) (reduce eager)) (\reducedResult -> applyIfNullary eager reducedResult remainingArgs))) - forLambda = - \l -> \args -> - let param = Core.lambdaParameter l - body = Core.lambdaBody l - arg = Lists.head args - remainingArgs = Lists.tail args - in (Eithers.bind (reduce eager (Rewriting.deannotateTerm arg)) (\reducedArg -> Eithers.bind (reduce eager (Rewriting.replaceFreeTermVariable param reducedArg body)) (\reducedResult -> applyIfNullary eager reducedResult remainingArgs))) - forPrimitive = - \prim -> \arity -> \args -> - let argList = Lists.take arity args - remainingArgs = Lists.drop arity args - in (Eithers.bind (Eithers.mapList (reduceArg eager) argList) (\reducedArgs -> - let strippedArgs = Lists.map Rewriting.deannotateTerm reducedArgs - in (Eithers.bind (Eithers.bimap mapErrorToString (\x -> x) (Graph.primitiveImplementation prim cx graph strippedArgs)) (\primResult -> Eithers.bind (reduce eager primResult) (\reducedResult -> applyIfNullary eager reducedResult remainingArgs))))) - in case stripped of - Core.TermApplication v0 -> applyIfNullary eager (Core.applicationFunction v0) (Lists.cons (Core.applicationArgument v0) args) - Core.TermFunction v0 -> case v0 of - Core.FunctionElimination v1 -> Logic.ifElse (Lists.null args) (Right original) (forElimination v1 args) - Core.FunctionLambda v1 -> Logic.ifElse (Lists.null args) (Right original) (forLambda v1 args) - Core.FunctionPrimitive v1 -> Eithers.bind (Lexical.requirePrimitive cx graph v1) (\prim -> - let arity = Arity.primitiveArity prim - in (Logic.ifElse (Equality.gt arity (Lists.length args)) (Right (applyToArguments original args)) (forPrimitive prim arity args))) - Core.TermVariable v0 -> - let mBinding = Lexical.dereferenceElement graph v0 - in (Maybes.maybe (Right (applyToArguments original args)) (\binding -> applyIfNullary eager (Core.bindingTerm binding) args) mBinding) - Core.TermLet v0 -> - let bindings = Core.letBindings v0 - body = Core.letBody v0 - letExpr = - \b -> Core.TermLet (Core.Let { - Core.letBindings = [ - b], - Core.letBody = (Core.TermVariable (Core.bindingName b))}) - expandBinding = - \b -> Core.Binding { - Core.bindingName = (Core.bindingName b), - Core.bindingTerm = (Rewriting.replaceFreeTermVariable (Core.bindingName b) (letExpr b) (Core.bindingTerm b)), - Core.bindingType = (Core.bindingType b)} - expandedBindings = Lists.map expandBinding bindings - substituteBinding = \term -> \b -> Rewriting.replaceFreeTermVariable (Core.bindingName b) (Core.bindingTerm b) term - substituteAll = \bs -> \term -> Lists.foldl substituteBinding term bs - expandedBody = substituteAll expandedBindings body - in (Eithers.bind (reduce eager expandedBody) (\reducedBody -> applyIfNullary eager reducedBody args)) - _ -> Right (applyToArguments original args) - mapping = - \recurse -> \mid -> Eithers.bind (Logic.ifElse (doRecurse eager mid) (recurse mid) (Right mid)) (\inner -> applyIfNullary eager inner []) - in (Rewriting.rewriteTermM mapping term) - --- | Whether a term is closed, i.e. represents a complete program -termIsClosed :: Core.Term -> Bool -termIsClosed term = Sets.null (Rewriting.freeVariablesInTerm term) - --- | Whether a term has been fully reduced to a value -termIsValue :: Core.Term -> Bool -termIsValue term = - - let forList = \els -> Lists.foldl (\b -> \t -> Logic.and b (termIsValue t)) True els - checkField = \f -> termIsValue (Core.fieldTerm f) - checkFields = \fields -> Lists.foldl (\b -> \f -> Logic.and b (checkField f)) True fields - functionIsValue = - \f -> case f of - Core.FunctionElimination v0 -> case v0 of - Core.EliminationWrap _ -> True - Core.EliminationRecord _ -> True - Core.EliminationUnion v1 -> Logic.and (checkFields (Core.caseStatementCases v1)) (Maybes.maybe True termIsValue (Core.caseStatementDefault v1)) - Core.FunctionLambda v0 -> termIsValue (Core.lambdaBody v0) - Core.FunctionPrimitive _ -> True - in case (Rewriting.deannotateTerm term) of - Core.TermApplication _ -> False - Core.TermEither v0 -> Eithers.either (\l -> termIsValue l) (\r -> termIsValue r) v0 - Core.TermLiteral _ -> True - Core.TermFunction v0 -> functionIsValue v0 - Core.TermList v0 -> forList v0 - Core.TermMap v0 -> Lists.foldl (\b -> \kv -> Logic.and b (Logic.and (termIsValue (Pairs.first kv)) (termIsValue (Pairs.second kv)))) True (Maps.toList v0) - Core.TermMaybe v0 -> Maybes.maybe True termIsValue v0 - Core.TermRecord v0 -> checkFields (Core.recordFields v0) - Core.TermSet v0 -> forList (Sets.toList v0) - Core.TermUnion v0 -> checkField (Core.injectionField v0) - Core.TermUnit -> True - Core.TermVariable _ -> False - _ -> False diff --git a/src/gen-main/haskell/Hydra/Reflect.hs b/src/gen-main/haskell/Hydra/Reflect.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Reflect.hs +++ /dev/null @@ -1,263 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Reflection functions for working with term, type, and literal type variants, as well as numeric precision. - -module Hydra.Reflect where - -import qualified Hydra.Core as Core -import qualified Hydra.Lib.Lists as Lists -import qualified Hydra.Util as Util -import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | Find the elimination inject (constructor) for a given elimination term -eliminationVariant :: Core.Elimination -> Variants.EliminationVariant -eliminationVariant x = - case x of - Core.EliminationRecord _ -> Variants.EliminationVariantRecord - Core.EliminationUnion _ -> Variants.EliminationVariantUnion - Core.EliminationWrap _ -> Variants.EliminationVariantWrap - --- | All elimination variants (constructors), in a canonical order -eliminationVariants :: [Variants.EliminationVariant] -eliminationVariants = - [ - Variants.EliminationVariantRecord, - Variants.EliminationVariantUnion, - Variants.EliminationVariantWrap] - --- | Find the precision of a given floating-point type -floatTypePrecision :: Core.FloatType -> Util.Precision -floatTypePrecision x = - case x of - Core.FloatTypeBigfloat -> Util.PrecisionArbitrary - Core.FloatTypeFloat32 -> Util.PrecisionBits 32 - Core.FloatTypeFloat64 -> Util.PrecisionBits 64 - --- | All floating-point types in a canonical order -floatTypes :: [Core.FloatType] -floatTypes = - [ - Core.FloatTypeBigfloat, - Core.FloatTypeFloat32, - Core.FloatTypeFloat64] - --- | Find the float type for a given floating-point value -floatValueType :: Core.FloatValue -> Core.FloatType -floatValueType x = - case x of - Core.FloatValueBigfloat _ -> Core.FloatTypeBigfloat - Core.FloatValueFloat32 _ -> Core.FloatTypeFloat32 - Core.FloatValueFloat64 _ -> Core.FloatTypeFloat64 - --- | Find the function inject (constructor) for a given function -functionVariant :: Core.Function -> Variants.FunctionVariant -functionVariant x = - case x of - Core.FunctionElimination _ -> Variants.FunctionVariantElimination - Core.FunctionLambda _ -> Variants.FunctionVariantLambda - Core.FunctionPrimitive _ -> Variants.FunctionVariantPrimitive - --- | All function variants (constructors), in a canonical order -functionVariants :: [Variants.FunctionVariant] -functionVariants = - [ - Variants.FunctionVariantElimination, - Variants.FunctionVariantLambda, - Variants.FunctionVariantPrimitive] - --- | Find whether a given integer type is signed (true) or unsigned (false) -integerTypeIsSigned :: Core.IntegerType -> Bool -integerTypeIsSigned x = - case x of - Core.IntegerTypeBigint -> True - Core.IntegerTypeInt8 -> True - Core.IntegerTypeInt16 -> True - Core.IntegerTypeInt32 -> True - Core.IntegerTypeInt64 -> True - Core.IntegerTypeUint8 -> False - Core.IntegerTypeUint16 -> False - Core.IntegerTypeUint32 -> False - Core.IntegerTypeUint64 -> False - --- | Find the precision of a given integer type -integerTypePrecision :: Core.IntegerType -> Util.Precision -integerTypePrecision x = - case x of - Core.IntegerTypeBigint -> Util.PrecisionArbitrary - Core.IntegerTypeInt8 -> Util.PrecisionBits 8 - Core.IntegerTypeInt16 -> Util.PrecisionBits 16 - Core.IntegerTypeInt32 -> Util.PrecisionBits 32 - Core.IntegerTypeInt64 -> Util.PrecisionBits 64 - Core.IntegerTypeUint8 -> Util.PrecisionBits 8 - Core.IntegerTypeUint16 -> Util.PrecisionBits 16 - Core.IntegerTypeUint32 -> Util.PrecisionBits 32 - Core.IntegerTypeUint64 -> Util.PrecisionBits 64 - --- | All integer types, in a canonical order -integerTypes :: [Core.IntegerType] -integerTypes = - [ - Core.IntegerTypeBigint, - Core.IntegerTypeInt8, - Core.IntegerTypeInt16, - Core.IntegerTypeInt32, - Core.IntegerTypeInt64, - Core.IntegerTypeUint8, - Core.IntegerTypeUint16, - Core.IntegerTypeUint32, - Core.IntegerTypeUint64] - --- | Find the integer type for a given integer value -integerValueType :: Core.IntegerValue -> Core.IntegerType -integerValueType x = - case x of - Core.IntegerValueBigint _ -> Core.IntegerTypeBigint - Core.IntegerValueInt8 _ -> Core.IntegerTypeInt8 - Core.IntegerValueInt16 _ -> Core.IntegerTypeInt16 - Core.IntegerValueInt32 _ -> Core.IntegerTypeInt32 - Core.IntegerValueInt64 _ -> Core.IntegerTypeInt64 - Core.IntegerValueUint8 _ -> Core.IntegerTypeUint8 - Core.IntegerValueUint16 _ -> Core.IntegerTypeUint16 - Core.IntegerValueUint32 _ -> Core.IntegerTypeUint32 - Core.IntegerValueUint64 _ -> Core.IntegerTypeUint64 - --- | Find the literal type for a given literal value -literalType :: Core.Literal -> Core.LiteralType -literalType x = - case x of - Core.LiteralBinary _ -> Core.LiteralTypeBinary - Core.LiteralBoolean _ -> Core.LiteralTypeBoolean - Core.LiteralFloat v0 -> (\injected_ -> Core.LiteralTypeFloat injected_) (floatValueType v0) - Core.LiteralInteger v0 -> (\injected_ -> Core.LiteralTypeInteger injected_) (integerValueType v0) - Core.LiteralString _ -> Core.LiteralTypeString - --- | Find the literal type inject (constructor) for a given literal value -literalTypeVariant :: Core.LiteralType -> Variants.LiteralVariant -literalTypeVariant x = - case x of - Core.LiteralTypeBinary -> Variants.LiteralVariantBinary - Core.LiteralTypeBoolean -> Variants.LiteralVariantBoolean - Core.LiteralTypeFloat _ -> Variants.LiteralVariantFloat - Core.LiteralTypeInteger _ -> Variants.LiteralVariantInteger - Core.LiteralTypeString -> Variants.LiteralVariantString - --- | All literal types, in a canonical order -literalTypes :: [Core.LiteralType] -literalTypes = - Lists.concat [ - [ - Core.LiteralTypeBinary, - Core.LiteralTypeBoolean], - (Lists.map (\x -> Core.LiteralTypeFloat x) floatTypes), - (Lists.map (\x -> Core.LiteralTypeInteger x) integerTypes), - [ - Core.LiteralTypeString]] - --- | Find the literal inject (constructor) for a given literal value -literalVariant :: Core.Literal -> Variants.LiteralVariant -literalVariant arg_ = literalTypeVariant (literalType arg_) - --- | All literal variants, in a canonical order -literalVariants :: [Variants.LiteralVariant] -literalVariants = - [ - Variants.LiteralVariantBinary, - Variants.LiteralVariantBoolean, - Variants.LiteralVariantFloat, - Variants.LiteralVariantInteger, - Variants.LiteralVariantString] - --- | Find the term inject (constructor) for a given term -termVariant :: Core.Term -> Variants.TermVariant -termVariant x = - case x of - Core.TermAnnotated _ -> Variants.TermVariantAnnotated - Core.TermApplication _ -> Variants.TermVariantApplication - Core.TermEither _ -> Variants.TermVariantEither - Core.TermFunction _ -> Variants.TermVariantFunction - Core.TermLet _ -> Variants.TermVariantLet - Core.TermList _ -> Variants.TermVariantList - Core.TermLiteral _ -> Variants.TermVariantLiteral - Core.TermMap _ -> Variants.TermVariantMap - Core.TermMaybe _ -> Variants.TermVariantMaybe - Core.TermPair _ -> Variants.TermVariantPair - Core.TermRecord _ -> Variants.TermVariantRecord - Core.TermSet _ -> Variants.TermVariantSet - Core.TermTypeApplication _ -> Variants.TermVariantTypeApplication - Core.TermTypeLambda _ -> Variants.TermVariantTypeLambda - Core.TermUnion _ -> Variants.TermVariantUnion - Core.TermUnit -> Variants.TermVariantUnit - Core.TermVariable _ -> Variants.TermVariantVariable - Core.TermWrap _ -> Variants.TermVariantWrap - --- | All term (expression) variants, in a canonical order -termVariants :: [Variants.TermVariant] -termVariants = - [ - Variants.TermVariantAnnotated, - Variants.TermVariantApplication, - Variants.TermVariantEither, - Variants.TermVariantFunction, - Variants.TermVariantList, - Variants.TermVariantLiteral, - Variants.TermVariantMap, - Variants.TermVariantMaybe, - Variants.TermVariantPair, - Variants.TermVariantRecord, - Variants.TermVariantSet, - Variants.TermVariantTypeLambda, - Variants.TermVariantTypeApplication, - Variants.TermVariantUnion, - Variants.TermVariantUnit, - Variants.TermVariantVariable, - Variants.TermVariantWrap] - --- | Find the type inject (constructor) for a given type -typeVariant :: Core.Type -> Variants.TypeVariant -typeVariant x = - case x of - Core.TypeAnnotated _ -> Variants.TypeVariantAnnotated - Core.TypeApplication _ -> Variants.TypeVariantApplication - Core.TypeEither _ -> Variants.TypeVariantEither - Core.TypeFunction _ -> Variants.TypeVariantFunction - Core.TypeForall _ -> Variants.TypeVariantForall - Core.TypeList _ -> Variants.TypeVariantList - Core.TypeLiteral _ -> Variants.TypeVariantLiteral - Core.TypeMap _ -> Variants.TypeVariantMap - Core.TypeMaybe _ -> Variants.TypeVariantMaybe - Core.TypePair _ -> Variants.TypeVariantPair - Core.TypeRecord _ -> Variants.TypeVariantRecord - Core.TypeSet _ -> Variants.TypeVariantSet - Core.TypeUnion _ -> Variants.TypeVariantUnion - Core.TypeUnit -> Variants.TypeVariantUnit - Core.TypeVariable _ -> Variants.TypeVariantVariable - Core.TypeVoid -> Variants.TypeVariantVoid - Core.TypeWrap _ -> Variants.TypeVariantWrap - --- | All type variants, in a canonical order -typeVariants :: [Variants.TypeVariant] -typeVariants = - [ - Variants.TypeVariantAnnotated, - Variants.TypeVariantApplication, - Variants.TypeVariantEither, - Variants.TypeVariantFunction, - Variants.TypeVariantForall, - Variants.TypeVariantList, - Variants.TypeVariantLiteral, - Variants.TypeVariantMap, - Variants.TypeVariantWrap, - Variants.TypeVariantMaybe, - Variants.TypeVariantPair, - Variants.TypeVariantRecord, - Variants.TypeVariantSet, - Variants.TypeVariantUnion, - Variants.TypeVariantUnit, - Variants.TypeVariantVariable, - Variants.TypeVariantVoid] diff --git a/src/gen-main/haskell/Hydra/Relational.hs b/src/gen-main/haskell/Hydra/Relational.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Relational.hs +++ /dev/null @@ -1,114 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | An interpretation of Codd's Relational Model, as described in 'A Relational Model of Data for Large Shared Data Banks' (1970). Types ('domains') and values are parameterized so as to allow for application-specific implementations. No special support is provided for 'nonsimple' domains; i.e. relations are assumed to be normalized. - -module Hydra.Relational where - -import qualified Hydra.Core as Core -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | A name for a domain which serves to identify the role played by that domain in the given relation; a 'role name' in Codd -newtype ColumnName = - ColumnName { - unColumnName :: String} - deriving (Eq, Ord, Read, Show) - -_ColumnName = Core.Name "hydra.relational.ColumnName" - --- | An abstract specification of the domain represented by a column in a relation; a role -data ColumnSchema t = - ColumnSchema { - -- | A unique name for the column - columnSchemaName :: ColumnName, - -- | The domain (type) of the column - columnSchemaDomain :: t} - deriving (Eq, Ord, Read, Show) - -_ColumnSchema = Core.Name "hydra.relational.ColumnSchema" - -_ColumnSchema_name = Core.Name "name" - -_ColumnSchema_domain = Core.Name "domain" - --- | A mapping from certain columns of a source relation to primary key columns of a target relation -data ForeignKey = - ForeignKey { - -- | The name of the target relation - foreignKeyForeignRelation :: RelationName, - -- | The mapping of source column names to target column names. The target column names must together make up the primary key of the target relation. - foreignKeyKeys :: (M.Map ColumnName ColumnName)} - deriving (Eq, Ord, Read, Show) - -_ForeignKey = Core.Name "hydra.relational.ForeignKey" - -_ForeignKey_foreignRelation = Core.Name "foreignRelation" - -_ForeignKey_keys = Core.Name "keys" - --- | A primary key of a relation, specified either as a single column, or as a list of columns -newtype PrimaryKey = - PrimaryKey { - unPrimaryKey :: [ColumnName]} - deriving (Eq, Ord, Read, Show) - -_PrimaryKey = Core.Name "hydra.relational.PrimaryKey" - --- | A set of distinct n-tuples; a table -newtype Relation v = - Relation { - unRelation :: [Row v]} - deriving (Eq, Ord, Read, Show) - -_Relation = Core.Name "hydra.relational.Relation" - --- | A unique relation (table) name -newtype RelationName = - RelationName { - unRelationName :: String} - deriving (Eq, Ord, Read, Show) - -_RelationName = Core.Name "hydra.relational.RelationName" - --- | An abstract relation; the name and columns of a relation without its actual data -data RelationSchema t = - RelationSchema { - -- | A unique name for the relation - relationSchemaName :: RelationName, - -- | A list of column specifications - relationSchemaColumns :: [ColumnSchema t], - -- | Any number of primary keys for the relation, each of which must be valid for this relation - relationSchemaPrimaryKeys :: [PrimaryKey], - -- | Any number of foreign keys, each of which must be valid for both this relation and the target relation - relationSchemaForeignKeys :: [ForeignKey]} - deriving (Eq, Ord, Read, Show) - -_RelationSchema = Core.Name "hydra.relational.RelationSchema" - -_RelationSchema_name = Core.Name "name" - -_RelationSchema_columns = Core.Name "columns" - -_RelationSchema_primaryKeys = Core.Name "primaryKeys" - -_RelationSchema_foreignKeys = Core.Name "foreignKeys" - --- | A domain-unordered (string-indexed, rather than position-indexed) relation -newtype Relationship v = - Relationship { - unRelationship :: (S.Set (M.Map ColumnName v))} - deriving (Eq, Ord, Read, Show) - -_Relationship = Core.Name "hydra.relational.Relationship" - --- | An n-tuple which is an element of a given relation -newtype Row v = - Row { - unRow :: [v]} - deriving (Eq, Ord, Read, Show) - -_Row = Core.Name "hydra.relational.Row" diff --git a/src/gen-main/haskell/Hydra/Rewriting.hs b/src/gen-main/haskell/Hydra/Rewriting.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Rewriting.hs +++ /dev/null @@ -1,1853 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Utilities for type and term rewriting and analysis. - -module Hydra.Rewriting where - -import qualified Hydra.Coders as Coders -import qualified Hydra.Core as Core -import qualified Hydra.Graph as Graph -import qualified Hydra.Lib.Eithers as Eithers -import qualified Hydra.Lib.Equality as Equality -import qualified Hydra.Lib.Lists as Lists -import qualified Hydra.Lib.Literals as Literals -import qualified Hydra.Lib.Logic as Logic -import qualified Hydra.Lib.Maps as Maps -import qualified Hydra.Lib.Math as Math -import qualified Hydra.Lib.Maybes as Maybes -import qualified Hydra.Lib.Pairs as Pairs -import qualified Hydra.Lib.Sets as Sets -import qualified Hydra.Lib.Strings as Strings -import qualified Hydra.Names as Names -import qualified Hydra.Paths as Paths -import qualified Hydra.Sorting as Sorting -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | Apply a term-level function inside any leading type lambdas -applyInsideTypeLambdasAndAnnotations :: (Core.Term -> Core.Term) -> Core.Term -> Core.Term -applyInsideTypeLambdasAndAnnotations f term0 = - case term0 of - Core.TermAnnotated v0 -> Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (applyInsideTypeLambdasAndAnnotations f (Core.annotatedTermBody v0)), - Core.annotatedTermAnnotation = (Core.annotatedTermAnnotation v0)}) - Core.TermTypeLambda v0 -> Core.TermTypeLambda (Core.TypeLambda { - Core.typeLambdaParameter = (Core.typeLambdaParameter v0), - Core.typeLambdaBody = (applyInsideTypeLambdasAndAnnotations f (Core.typeLambdaBody v0))}) - _ -> f term0 - --- | Strip type annotations from the top levels of a term -deannotateAndDetypeTerm :: Core.Term -> Core.Term -deannotateAndDetypeTerm t = - case t of - Core.TermAnnotated v0 -> deannotateAndDetypeTerm (Core.annotatedTermBody v0) - Core.TermTypeApplication v0 -> deannotateAndDetypeTerm (Core.typeApplicationTermBody v0) - Core.TermTypeLambda v0 -> deannotateAndDetypeTerm (Core.typeLambdaBody v0) - _ -> t - --- | Strip all annotations (including System F type annotations) from the top levels of a term -deannotateTerm :: Core.Term -> Core.Term -deannotateTerm t = - case t of - Core.TermAnnotated v0 -> deannotateTerm (Core.annotatedTermBody v0) - _ -> t - --- | Strip all annotations from a term -deannotateType :: Core.Type -> Core.Type -deannotateType t = - case t of - Core.TypeAnnotated v0 -> deannotateType (Core.annotatedTypeBody v0) - _ -> t - --- | Strip any top-level type lambdas from a type, extracting the (possibly nested) type body -deannotateTypeParameters :: Core.Type -> Core.Type -deannotateTypeParameters t = - case (deannotateType t) of - Core.TypeForall v0 -> deannotateTypeParameters (Core.forallTypeBody v0) - _ -> t - --- | Recursively strip all annotations from a type -deannotateTypeRecursive :: Core.Type -> Core.Type -deannotateTypeRecursive typ = - - let strip = - \recurse -> \typ -> - let rewritten = recurse typ - in case rewritten of - Core.TypeAnnotated v0 -> Core.annotatedTypeBody v0 - _ -> rewritten - in (rewriteType strip typ) - --- | Recursively strip all annotations from a type scheme -deannotateTypeSchemeRecursive :: Core.TypeScheme -> Core.TypeScheme -deannotateTypeSchemeRecursive ts = - - let vars = Core.typeSchemeVariables ts - typ = Core.typeSchemeType ts - constraints = Core.typeSchemeConstraints ts - in Core.TypeScheme { - Core.typeSchemeVariables = vars, - Core.typeSchemeType = (deannotateTypeRecursive typ), - Core.typeSchemeConstraints = constraints} - --- | Strip System F type annotations from the top levels of a term, but leave application-specific annotations intact -detypeTerm :: Core.Term -> Core.Term -detypeTerm t = - case t of - Core.TermAnnotated v0 -> - let subj = Core.annotatedTermBody v0 - ann = Core.annotatedTermAnnotation v0 - in (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (detypeTerm subj), - Core.annotatedTermAnnotation = ann})) - Core.TermTypeApplication v0 -> deannotateAndDetypeTerm (Core.typeApplicationTermBody v0) - Core.TermTypeLambda v0 -> deannotateAndDetypeTerm (Core.typeLambdaBody v0) - _ -> t - --- | Extend a graph by descending into a lambda body -extendGraphForLambda :: Graph.Graph -> Core.Lambda -> Graph.Graph -extendGraphForLambda g lam = - - let var = Core.lambdaParameter lam - in Graph.Graph { - Graph.graphBoundTerms = (Graph.graphBoundTerms g), - Graph.graphBoundTypes = (Maybes.maybe (Graph.graphBoundTypes g) (\dom -> Maps.insert var (fTypeToTypeScheme dom) (Graph.graphBoundTypes g)) (Core.lambdaDomain lam)), - Graph.graphClassConstraints = (Graph.graphClassConstraints g), - Graph.graphLambdaVariables = (Sets.insert var (Graph.graphLambdaVariables g)), - Graph.graphMetadata = (Maps.delete var (Graph.graphMetadata g)), - Graph.graphPrimitives = (Graph.graphPrimitives g), - Graph.graphSchemaTypes = (Graph.graphSchemaTypes g), - Graph.graphTypeVariables = (Graph.graphTypeVariables g)} - --- | Extend a graph by descending into a let body -extendGraphForLet :: (Graph.Graph -> Core.Binding -> Maybe Core.Term) -> Graph.Graph -> Core.Let -> Graph.Graph -extendGraphForLet forBinding g letrec = - - let bindings = Core.letBindings letrec - g2 = extendGraphWithBindings bindings g - in Graph.Graph { - Graph.graphBoundTerms = (Maps.union (Maps.fromList (Lists.map (\b -> (Core.bindingName b, (Core.bindingTerm b))) bindings)) (Graph.graphBoundTerms g)), - Graph.graphBoundTypes = (Maps.union (Maps.fromList (Maybes.cat (Lists.map (\b -> Maybes.map (\ts -> (Core.bindingName b, ts)) (Core.bindingType b)) bindings))) (Graph.graphBoundTypes g)), - Graph.graphClassConstraints = (Graph.graphClassConstraints g), - Graph.graphLambdaVariables = (Lists.foldl (\s -> \b -> Sets.delete (Core.bindingName b) s) (Graph.graphLambdaVariables g) bindings), - Graph.graphMetadata = (Graph.graphMetadata (Lists.foldl (\gAcc -> \b -> - let m = Graph.graphMetadata gAcc - newMeta = Maybes.maybe (Maps.delete (Core.bindingName b) m) (\t -> Maps.insert (Core.bindingName b) t m) (forBinding gAcc b) - in Graph.Graph { - Graph.graphBoundTerms = (Graph.graphBoundTerms gAcc), - Graph.graphBoundTypes = (Graph.graphBoundTypes gAcc), - Graph.graphClassConstraints = (Graph.graphClassConstraints gAcc), - Graph.graphLambdaVariables = (Graph.graphLambdaVariables gAcc), - Graph.graphMetadata = newMeta, - Graph.graphPrimitives = (Graph.graphPrimitives gAcc), - Graph.graphSchemaTypes = (Graph.graphSchemaTypes gAcc), - Graph.graphTypeVariables = (Graph.graphTypeVariables gAcc)}) g2 bindings)), - Graph.graphPrimitives = (Graph.graphPrimitives g), - Graph.graphSchemaTypes = (Graph.graphSchemaTypes g), - Graph.graphTypeVariables = (Graph.graphTypeVariables g)} - --- | Extend a graph by descending into a type lambda body -extendGraphForTypeLambda :: Graph.Graph -> Core.TypeLambda -> Graph.Graph -extendGraphForTypeLambda g tlam = - - let name = Core.typeLambdaParameter tlam - in Graph.Graph { - Graph.graphBoundTerms = (Graph.graphBoundTerms g), - Graph.graphBoundTypes = (Graph.graphBoundTypes g), - Graph.graphClassConstraints = (Graph.graphClassConstraints g), - Graph.graphLambdaVariables = (Graph.graphLambdaVariables g), - Graph.graphMetadata = (Graph.graphMetadata g), - Graph.graphPrimitives = (Graph.graphPrimitives g), - Graph.graphSchemaTypes = (Graph.graphSchemaTypes g), - Graph.graphTypeVariables = (Sets.insert name (Graph.graphTypeVariables g))} - --- | Add bindings to an existing graph -extendGraphWithBindings :: [Core.Binding] -> Graph.Graph -> Graph.Graph -extendGraphWithBindings bindings g = - - let newTerms = Maps.fromList (Lists.map (\b -> (Core.bindingName b, (Core.bindingTerm b))) bindings) - newTypes = - Maps.fromList (Maybes.cat (Lists.map (\b -> Maybes.map (\ts -> (Core.bindingName b, ts)) (Core.bindingType b)) bindings)) - in Graph.Graph { - Graph.graphBoundTerms = (Maps.union newTerms (Graph.graphBoundTerms g)), - Graph.graphBoundTypes = (Maps.union newTypes (Graph.graphBoundTypes g)), - Graph.graphClassConstraints = (Graph.graphClassConstraints g), - Graph.graphLambdaVariables = (Graph.graphLambdaVariables g), - Graph.graphMetadata = (Graph.graphMetadata g), - Graph.graphPrimitives = (Graph.graphPrimitives g), - Graph.graphSchemaTypes = (Graph.graphSchemaTypes g), - Graph.graphTypeVariables = (Graph.graphTypeVariables g)} - --- | Convert a forall type to a type scheme -fTypeToTypeScheme :: Core.Type -> Core.TypeScheme -fTypeToTypeScheme typ = - - let gatherForall = - \vars -> \typ -> case (deannotateType typ) of - Core.TypeForall v0 -> gatherForall (Lists.cons (Core.forallTypeParameter v0) vars) (Core.forallTypeBody v0) - _ -> Core.TypeScheme { - Core.typeSchemeVariables = (Lists.reverse vars), - Core.typeSchemeType = typ, - Core.typeSchemeConstraints = Nothing} - in (gatherForall [] typ) - --- | Flatten nested let expressions -flattenLetTerms :: Core.Term -> Core.Term -flattenLetTerms term = - - let rewriteBinding = - \binding -> - let key0 = Core.bindingName binding - val0 = Core.bindingTerm binding - t = Core.bindingType binding - in case val0 of - Core.TermAnnotated v0 -> - let val1 = Core.annotatedTermBody v0 - ann = Core.annotatedTermAnnotation v0 - recursive = - rewriteBinding (Core.Binding { - Core.bindingName = key0, - Core.bindingTerm = val1, - Core.bindingType = t}) - innerBinding = Pairs.first recursive - deps = Pairs.second recursive - val2 = Core.bindingTerm innerBinding - in (Core.Binding { - Core.bindingName = key0, - Core.bindingTerm = (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = val2, - Core.annotatedTermAnnotation = ann})), - Core.bindingType = t}, deps) - Core.TermLet v0 -> - let bindings1 = Core.letBindings v0 - body1 = Core.letBody v0 - prefix = Strings.cat2 (Core.unName key0) "_" - qualify = \n -> Core.Name (Strings.cat2 prefix (Core.unName n)) - toSubstPair = \b -> (Core.bindingName b, (qualify (Core.bindingName b))) - subst = Maps.fromList (Lists.map toSubstPair bindings1) - replaceVars = substituteVariables subst - newBody = replaceVars body1 - newBinding = - \b -> Core.Binding { - Core.bindingName = (qualify (Core.bindingName b)), - Core.bindingTerm = (replaceVars (Core.bindingTerm b)), - Core.bindingType = (Core.bindingType b)} - in (Core.Binding { - Core.bindingName = key0, - Core.bindingTerm = newBody, - Core.bindingType = t}, (Lists.map newBinding bindings1)) - _ -> (Core.Binding { - Core.bindingName = key0, - Core.bindingTerm = val0, - Core.bindingType = t}, []) - flattenBodyLet = - \bindings -> \body -> case body of - Core.TermLet v0 -> - let innerBindings = Core.letBindings v0 - innerBody = Core.letBody v0 - in (flattenBodyLet (Lists.concat2 bindings innerBindings) innerBody) - _ -> (Lists.concat2 [] bindings, body) - flatten = - \recurse -> \term -> - let rewritten = recurse term - in case rewritten of - Core.TermLet v0 -> - let bindings = Core.letBindings v0 - body = Core.letBody v0 - forResult = \hr -> Lists.concat2 (Pairs.second hr) (Lists.pure (Pairs.first hr)) - flattenedBindings = Lists.concat (Lists.map (\arg_ -> forResult (rewriteBinding arg_)) bindings) - merged = flattenBodyLet flattenedBindings body - newBindings = Pairs.first merged - newBody = Pairs.second merged - in (Core.TermLet (Core.Let { - Core.letBindings = newBindings, - Core.letBody = newBody})) - _ -> rewritten - in (rewriteTerm flatten term) - --- | Fold over a term, traversing its subterms in the specified order -foldOverTerm :: Coders.TraversalOrder -> (t0 -> Core.Term -> t0) -> t0 -> Core.Term -> t0 -foldOverTerm order fld b0 term = - case order of - Coders.TraversalOrderPre -> Lists.foldl (foldOverTerm order fld) (fld b0 term) (subterms term) - Coders.TraversalOrderPost -> fld (Lists.foldl (foldOverTerm order fld) b0 (subterms term)) term - --- | Fold over a type, traversing its subtypes in the specified order -foldOverType :: Coders.TraversalOrder -> (t0 -> Core.Type -> t0) -> t0 -> Core.Type -> t0 -foldOverType order fld b0 typ = - case order of - Coders.TraversalOrderPre -> Lists.foldl (foldOverType order fld) (fld b0 typ) (subtypes typ) - Coders.TraversalOrderPost -> fld (Lists.foldl (foldOverType order fld) b0 (subtypes typ)) typ - --- | Fold over a term to produce a value, with both Graph and accessor path tracked. Like rewriteAndFoldTermWithGraphAndPath, but only folds without rewriting. The Graph is automatically updated when descending into lambdas, lets, and type lambdas. -foldTermWithGraphAndPath :: ((t0 -> Core.Term -> t0) -> [Paths.SubtermStep] -> Graph.Graph -> t0 -> Core.Term -> t0) -> Graph.Graph -> t0 -> Core.Term -> t0 -foldTermWithGraphAndPath f cx0 val0 term0 = - - let wrapper = - \recurse -> \path -> \cx -> \val -> \term -> - let recurseForUser = - \valIn -> \subterm -> - let r = recurse valIn subterm - in (Pairs.first r) - in (f recurseForUser path cx val term, term) - result = rewriteAndFoldTermWithGraphAndPath wrapper cx0 val0 term0 - in (Pairs.first result) - --- | Get the set of free type variables in a term (including schema names, where they appear in type annotations). In this context, only the type schemes of let bindings can bind type variables; type lambdas do not. -freeTypeVariablesInTerm :: Core.Term -> S.Set Core.Name -freeTypeVariablesInTerm term0 = - - let allOf = \sets -> Lists.foldl Sets.union Sets.empty sets - tryType = \tvars -> \typ -> Sets.difference (freeVariablesInType typ) tvars - getAll = - \vars -> \term -> - let recurse = getAll vars - dflt = allOf (Lists.map recurse (subterms term)) - in case term of - Core.TermFunction v0 -> case v0 of - Core.FunctionElimination _ -> dflt - Core.FunctionLambda v1 -> - let domt = Maybes.maybe Sets.empty (tryType vars) (Core.lambdaDomain v1) - in (Sets.union domt (recurse (Core.lambdaBody v1))) - _ -> dflt - Core.TermLet v0 -> - let forBinding = - \b -> - let newVars = Maybes.maybe vars (\ts -> Sets.union vars (Sets.fromList (Core.typeSchemeVariables ts))) (Core.bindingType b) - in (Sets.union (getAll newVars (Core.bindingTerm b)) (Maybes.maybe Sets.empty (\ts -> tryType newVars (Core.typeSchemeType ts)) (Core.bindingType b))) - in (Sets.union (allOf (Lists.map forBinding (Core.letBindings v0))) (recurse (Core.letBody v0))) - Core.TermTypeApplication v0 -> Sets.union (tryType vars (Core.typeApplicationTermType v0)) (recurse (Core.typeApplicationTermBody v0)) - Core.TermTypeLambda v0 -> Sets.union (tryType vars (Core.TypeVariable (Core.typeLambdaParameter v0))) (recurse (Core.typeLambdaBody v0)) - _ -> dflt - in (getAll Sets.empty term0) - --- | Find the free variables (i.e. variables not bound by a lambda or let) in a term -freeVariablesInTerm :: Core.Term -> S.Set Core.Name -freeVariablesInTerm term = - - let dfltVars = \_ -> Lists.foldl (\s -> \t -> Sets.union s (freeVariablesInTerm t)) Sets.empty (subterms term) - in case term of - Core.TermFunction v0 -> case v0 of - Core.FunctionLambda v1 -> Sets.delete (Core.lambdaParameter v1) (freeVariablesInTerm (Core.lambdaBody v1)) - _ -> dfltVars () - Core.TermLet v0 -> Sets.difference (dfltVars ()) (Sets.fromList (Lists.map Core.bindingName (Core.letBindings v0))) - Core.TermVariable v0 -> Sets.singleton v0 - _ -> dfltVars () - --- | Find the free variables (i.e. variables not bound by a lambda or let) in a type -freeVariablesInType :: Core.Type -> S.Set Core.Name -freeVariablesInType typ = - - let dfltVars = Lists.foldl (\s -> \t -> Sets.union s (freeVariablesInType t)) Sets.empty (subtypes typ) - in case typ of - Core.TypeForall v0 -> Sets.delete (Core.forallTypeParameter v0) (freeVariablesInType (Core.forallTypeBody v0)) - Core.TypeVariable v0 -> Sets.singleton v0 - _ -> dfltVars - --- | Find the free variables in a type in deterministic left-to-right order -freeVariablesInTypeOrdered :: Core.Type -> [Core.Name] -freeVariablesInTypeOrdered typ = - - let collectVars = - \boundVars -> \t -> case t of - Core.TypeVariable v0 -> Logic.ifElse (Sets.member v0 boundVars) [] [ - v0] - Core.TypeForall v0 -> collectVars (Sets.insert (Core.forallTypeParameter v0) boundVars) (Core.forallTypeBody v0) - _ -> Lists.concat (Lists.map (collectVars boundVars) (subtypes t)) - in (Lists.nub (collectVars Sets.empty typ)) - --- | Find free variables in a type scheme -freeVariablesInTypeScheme :: Core.TypeScheme -> S.Set Core.Name -freeVariablesInTypeScheme ts = - - let vars = Core.typeSchemeVariables ts - t = Core.typeSchemeType ts - in (Sets.difference (freeVariablesInType t) (Sets.fromList vars)) - --- | Find free variables in a type scheme (simple version) -freeVariablesInTypeSchemeSimple :: Core.TypeScheme -> S.Set Core.Name -freeVariablesInTypeSchemeSimple ts = - - let vars = Core.typeSchemeVariables ts - t = Core.typeSchemeType ts - in (Sets.difference (freeVariablesInTypeSimple t) (Sets.fromList vars)) - --- | Same as freeVariablesInType, but ignores the binding action of lambda types -freeVariablesInTypeSimple :: Core.Type -> S.Set Core.Name -freeVariablesInTypeSimple typ = - - let helper = - \types -> \typ -> case typ of - Core.TypeVariable v0 -> Sets.insert v0 types - _ -> types - in (foldOverType Coders.TraversalOrderPre helper Sets.empty typ) - --- | Inline all type variables in a type using the provided schema (Either version). Note: this function is only appropriate for nonrecursive type definitions -inlineType :: M.Map Core.Name Core.Type -> Core.Type -> Either String Core.Type -inlineType schema typ = - - let f = - \recurse -> \typ -> - let afterRecurse = - \tr -> case tr of - Core.TypeVariable v0 -> Maybes.maybe (Left (Strings.cat2 "No such type in schema: " (Core.unName v0))) (inlineType schema) (Maps.lookup v0 schema) - _ -> Right tr - in (Eithers.bind (recurse typ) (\tr -> afterRecurse tr)) - in (rewriteTypeM f typ) - --- | Check whether a variable is free (not bound) in a term -isFreeVariableInTerm :: Core.Name -> Core.Term -> Bool -isFreeVariableInTerm v term = Logic.not (Sets.member v (freeVariablesInTerm term)) - --- | Check whether a term is a lambda, possibly nested within let and/or annotation terms -isLambda :: Core.Term -> Bool -isLambda term = - case (deannotateTerm term) of - Core.TermFunction v0 -> case v0 of - Core.FunctionLambda _ -> True - _ -> False - Core.TermLet v0 -> isLambda (Core.letBody v0) - _ -> False - --- | Rewrite terms like `let foo = bar in λx.baz` to `λx.let foo = bar in baz`, lifting lambda-bound variables above let-bound variables, recursively. This is helpful for targets such as Python. -liftLambdaAboveLet :: Core.Term -> Core.Term -liftLambdaAboveLet term0 = - - let rewrite = - \recurse -> \term -> - let rewriteBinding = - \b -> Core.Binding { - Core.bindingName = (Core.bindingName b), - Core.bindingTerm = (rewrite recurse (Core.bindingTerm b)), - Core.bindingType = (Core.bindingType b)} - rewriteBindings = \bs -> Lists.map rewriteBinding bs - digForLambdas = - \original -> \cons -> \term -> case term of - Core.TermAnnotated v0 -> digForLambdas original (\t -> Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (cons t), - Core.annotatedTermAnnotation = (Core.annotatedTermAnnotation v0)})) (Core.annotatedTermBody v0) - Core.TermFunction v0 -> case v0 of - Core.FunctionLambda v1 -> Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.lambdaParameter v1), - Core.lambdaDomain = (Core.lambdaDomain v1), - Core.lambdaBody = (digForLambdas (cons (Core.lambdaBody v1)) (\t -> cons t) (Core.lambdaBody v1))})) - _ -> recurse original - Core.TermLet v0 -> digForLambdas original (\t -> cons (Core.TermLet (Core.Let { - Core.letBindings = (rewriteBindings (Core.letBindings v0)), - Core.letBody = t}))) (Core.letBody v0) - _ -> recurse original - in case term of - Core.TermLet v0 -> digForLambdas term (\t -> Core.TermLet (Core.Let { - Core.letBindings = (rewriteBindings (Core.letBindings v0)), - Core.letBody = t})) (Core.letBody v0) - _ -> recurse term - in (rewriteTerm rewrite term0) - --- | Apply a transformation to the first type beneath a chain of annotations -mapBeneathTypeAnnotations :: (Core.Type -> Core.Type) -> Core.Type -> Core.Type -mapBeneathTypeAnnotations f t = - case t of - Core.TypeAnnotated v0 -> Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (mapBeneathTypeAnnotations f (Core.annotatedTypeBody v0)), - Core.annotatedTypeAnnotation = (Core.annotatedTypeAnnotation v0)}) - _ -> f t - --- | Recursively replace the type variables of let bindings with the systematic type variables t0, t1, t2, ... -normalizeTypeVariablesInTerm :: Core.Term -> Core.Term -normalizeTypeVariablesInTerm term = - - let replaceName = \subst -> \v -> Maybes.fromMaybe v (Maps.lookup v subst) - substType = - \subst -> \typ -> - let rewrite = - \recurse -> \typ -> case typ of - Core.TypeVariable v0 -> Core.TypeVariable (replaceName subst v0) - _ -> recurse typ - in (rewriteType rewrite typ) - rewriteWithSubst = - \state -> \term0 -> - let sb = Pairs.first state - next = Pairs.second state - subst = Pairs.first sb - boundVars = Pairs.second sb - rewrite = - \recurse -> \term -> case term of - Core.TermFunction v0 -> case v0 of - Core.FunctionElimination _ -> recurse term - Core.FunctionLambda v1 -> - let domain = Core.lambdaDomain v1 - in (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.lambdaParameter v1), - Core.lambdaDomain = (Maybes.map (substType subst) domain), - Core.lambdaBody = (rewriteWithSubst ((subst, boundVars), next) (Core.lambdaBody v1))}))) - _ -> recurse term - Core.TermLet v0 -> - let bindings0 = Core.letBindings v0 - body0 = Core.letBody v0 - step = - \acc -> \bs -> Logic.ifElse (Lists.null bs) (Lists.reverse acc) ( - let b = Lists.head bs - tl = Lists.tail bs - noType = - - let newVal = rewriteWithSubst ((subst, boundVars), next) (Core.bindingTerm b) - b1 = - Core.Binding { - Core.bindingName = (Core.bindingName b), - Core.bindingTerm = newVal, - Core.bindingType = Nothing} - in (step (Lists.cons b1 acc) tl) - withType = - \ts -> - let vars = Core.typeSchemeVariables ts - typ = Core.typeSchemeType ts - k = Lists.length vars - gen = - \i -> \rem -> \acc2 -> - let ti = Core.Name (Strings.cat2 "t" (Literals.showInt32 (Math.add next i))) - in (Logic.ifElse (Equality.equal rem 0) (Lists.reverse acc2) (gen (Math.add i 1) (Math.sub rem 1) (Lists.cons ti acc2))) - newVars = gen 0 k [] - newSubst = Maps.union (Maps.fromList (Lists.zip vars newVars)) subst - newBound = Sets.union boundVars (Sets.fromList newVars) - newVal = rewriteWithSubst ((newSubst, newBound), (Math.add next k)) (Core.bindingTerm b) - renameConstraintKeys = - \constraintMap -> Maps.fromList (Lists.map (\p -> - let oldName = Pairs.first p - meta = Pairs.second p - newName = Maybes.fromMaybe oldName (Maps.lookup oldName newSubst) - in (newName, meta)) (Maps.toList constraintMap)) - oldConstraints = Core.typeSchemeConstraints ts - newConstraints = Maybes.map renameConstraintKeys oldConstraints - b1 = - Core.Binding { - Core.bindingName = (Core.bindingName b), - Core.bindingTerm = newVal, - Core.bindingType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = newVars, - Core.typeSchemeType = (substType newSubst typ), - Core.typeSchemeConstraints = newConstraints}))} - in (step (Lists.cons b1 acc) tl) - in (Maybes.maybe noType (\ts -> withType ts) (Core.bindingType b))) - bindings1 = step [] bindings0 - in (Core.TermLet (Core.Let { - Core.letBindings = bindings1, - Core.letBody = (rewriteWithSubst ((subst, boundVars), next) body0)})) - Core.TermTypeApplication v0 -> Core.TermTypeApplication (Core.TypeApplicationTerm { - Core.typeApplicationTermBody = (rewriteWithSubst ((subst, boundVars), next) (Core.typeApplicationTermBody v0)), - Core.typeApplicationTermType = (substType subst (Core.typeApplicationTermType v0))}) - Core.TermTypeLambda v0 -> Core.TermTypeLambda (Core.TypeLambda { - Core.typeLambdaParameter = (replaceName subst (Core.typeLambdaParameter v0)), - Core.typeLambdaBody = (rewriteWithSubst ((subst, boundVars), next) (Core.typeLambdaBody v0))}) - _ -> recurse term - in (rewriteTerm rewrite term0) - in (rewriteWithSubst ((Maps.empty, Sets.empty), 0) term) - --- | Given a let expression, remove any unused bindings. The resulting expression is still a let, even if has no remaining bindings -pruneLet :: Core.Let -> Core.Let -pruneLet l = - - let bindingMap = Maps.fromList (Lists.map (\b -> (Core.bindingName b, (Core.bindingTerm b))) (Core.letBindings l)) - rootName = Core.Name "[[[root]]]" - adj = - \n -> Sets.intersection (Sets.fromList (Maps.keys bindingMap)) (freeVariablesInTerm (Logic.ifElse (Equality.equal n rootName) (Core.letBody l) (Maybes.fromJust (Maps.lookup n bindingMap)))) - reachable = Sorting.findReachableNodes adj rootName - prunedBindings = Lists.filter (\b -> Sets.member (Core.bindingName b) reachable) (Core.letBindings l) - in Core.Let { - Core.letBindings = prunedBindings, - Core.letBody = (Core.letBody l)} - --- | Recursively remove term annotations, including within subterms -removeTermAnnotations :: Core.Term -> Core.Term -removeTermAnnotations term = - - let remove = - \recurse -> \term -> - let rewritten = recurse term - in case term of - Core.TermAnnotated v0 -> Core.annotatedTermBody v0 - _ -> rewritten - in (rewriteTerm remove term) - --- | Recursively remove type annotations, including within subtypes -removeTypeAnnotations :: Core.Type -> Core.Type -removeTypeAnnotations typ = - - let remove = - \recurse -> \typ -> - let rewritten = recurse typ - in case rewritten of - Core.TypeAnnotated v0 -> Core.annotatedTypeBody v0 - _ -> rewritten - in (rewriteType remove typ) - --- | Strip type annotations (TypeLambda, TypeApplication, binding type schemes) from terms while preserving lambda domain types and other annotations -removeTypeAnnotationsFromTerm :: Core.Term -> Core.Term -removeTypeAnnotationsFromTerm term = - - let strip = - \recurse -> \term -> - let rewritten = recurse term - stripBinding = - \b -> Core.Binding { - Core.bindingName = (Core.bindingName b), - Core.bindingTerm = (Core.bindingTerm b), - Core.bindingType = Nothing} - in case rewritten of - Core.TermLet v0 -> Core.TermLet (Core.Let { - Core.letBindings = (Lists.map stripBinding (Core.letBindings v0)), - Core.letBody = (Core.letBody v0)}) - Core.TermTypeApplication v0 -> Core.typeApplicationTermBody v0 - Core.TermTypeLambda v0 -> Core.typeLambdaBody v0 - _ -> rewritten - in (rewriteTerm strip term) - --- | Strip type annotations from terms while preserving other annotations -removeTypesFromTerm :: Core.Term -> Core.Term -removeTypesFromTerm term = - - let strip = - \recurse -> \term -> - let rewritten = recurse term - stripBinding = - \b -> Core.Binding { - Core.bindingName = (Core.bindingName b), - Core.bindingTerm = (Core.bindingTerm b), - Core.bindingType = Nothing} - in case rewritten of - Core.TermFunction v0 -> case v0 of - Core.FunctionElimination v1 -> Core.TermFunction (Core.FunctionElimination v1) - Core.FunctionLambda v1 -> Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.lambdaParameter v1), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.lambdaBody v1)})) - _ -> Core.TermFunction v0 - Core.TermLet v0 -> Core.TermLet (Core.Let { - Core.letBindings = (Lists.map stripBinding (Core.letBindings v0)), - Core.letBody = (Core.letBody v0)}) - Core.TermTypeApplication v0 -> Core.typeApplicationTermBody v0 - Core.TermTypeLambda v0 -> Core.typeLambdaBody v0 - _ -> rewritten - in (rewriteTerm strip term) - --- | Replace a free variable in a term -replaceFreeTermVariable :: Core.Name -> Core.Term -> Core.Term -> Core.Term -replaceFreeTermVariable vold tnew term = - - let rewrite = - \recurse -> \t -> case t of - Core.TermFunction v0 -> case v0 of - Core.FunctionLambda v1 -> - let v = Core.lambdaParameter v1 - in (Logic.ifElse (Equality.equal v vold) t (recurse t)) - _ -> recurse t - Core.TermVariable v0 -> Logic.ifElse (Equality.equal v0 vold) tnew (Core.TermVariable v0) - _ -> recurse t - in (rewriteTerm rewrite term) - --- | Replace free occurrences of a name in a type -replaceFreeTypeVariable :: Core.Name -> Core.Type -> Core.Type -> Core.Type -replaceFreeTypeVariable v rep typ = - - let mapExpr = - \recurse -> \t -> case t of - Core.TypeForall v0 -> Logic.ifElse (Equality.equal v (Core.forallTypeParameter v0)) t (Core.TypeForall (Core.ForallType { - Core.forallTypeParameter = (Core.forallTypeParameter v0), - Core.forallTypeBody = (recurse (Core.forallTypeBody v0))})) - Core.TypeVariable v0 -> Logic.ifElse (Equality.equal v v0) rep t - _ -> recurse t - in (rewriteType mapExpr typ) - --- | Replace all occurrences of simple typedefs (type aliases) with the aliased types, recursively -replaceTypedefs :: M.Map Core.Name Core.TypeScheme -> Core.Type -> Core.Type -replaceTypedefs types typ0 = - - let rewrite = - \recurse -> \typ -> case typ of - Core.TypeAnnotated v0 -> Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (rewrite recurse (Core.annotatedTypeBody v0)), - Core.annotatedTypeAnnotation = (Core.annotatedTypeAnnotation v0)}) - Core.TypeRecord _ -> typ - Core.TypeUnion _ -> typ - Core.TypeVariable v0 -> - let forMono = - \t -> case t of - Core.TypeRecord _ -> typ - Core.TypeUnion _ -> typ - Core.TypeWrap _ -> typ - _ -> rewrite recurse t - forTypeScheme = - \ts -> - let t = Core.typeSchemeType ts - in (Logic.ifElse (Lists.null (Core.typeSchemeVariables ts)) (forMono t) typ) - in (Maybes.maybe typ (\ts -> forTypeScheme ts) (Maps.lookup v0 types)) - Core.TypeWrap _ -> typ - _ -> recurse typ - in (rewriteType rewrite typ0) - --- | Rewrite a term, and at the same time, fold a function over it, accumulating a value -rewriteAndFoldTerm :: ((t0 -> Core.Term -> (t0, Core.Term)) -> t0 -> Core.Term -> (t0, Core.Term)) -> t0 -> Core.Term -> (t0, Core.Term) -rewriteAndFoldTerm f term0 = - - let fsub = - \recurse -> \val0 -> \term0 -> - let forSingle = - \rec -> \cons -> \val -> \term -> - let r = rec val term - in (Pairs.first r, (cons (Pairs.second r))) - forMany = - \rec -> \cons -> \val -> \els -> - let rr = - Lists.foldl (\r -> \el -> - let r2 = rec (Pairs.first r) el - in (Pairs.first r2, (Lists.cons (Pairs.second r2) (Pairs.second r)))) (val, []) els - in (Pairs.first rr, (cons (Lists.reverse (Pairs.second rr)))) - forField = - \val -> \field -> - let r = recurse val (Core.fieldTerm field) - in (Pairs.first r, Core.Field { - Core.fieldName = (Core.fieldName field), - Core.fieldTerm = (Pairs.second r)}) - forFields = forMany forField (\x -> x) - forPair = - \val -> \kv -> - let rk = recurse val (Pairs.first kv) - rv = recurse (Pairs.first rk) (Pairs.second kv) - in (Pairs.first rv, (Pairs.second rk, (Pairs.second rv))) - forBinding = - \val -> \binding -> - let r = recurse val (Core.bindingTerm binding) - in (Pairs.first r, Core.Binding { - Core.bindingName = (Core.bindingName binding), - Core.bindingTerm = (Pairs.second r), - Core.bindingType = (Core.bindingType binding)}) - forElimination = - \val -> \elm -> - let r = - case elm of - Core.EliminationUnion v0 -> - let rmd = Maybes.map (recurse val) (Core.caseStatementDefault v0) - val1 = Maybes.maybe val Pairs.first rmd - rcases = forFields val1 (Core.caseStatementCases v0) - in (Pairs.first rcases, (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.caseStatementTypeName v0), - Core.caseStatementDefault = (Maybes.map Pairs.second rmd), - Core.caseStatementCases = (Pairs.second rcases)}))) - _ -> (val, elm) - in (Pairs.first r, (Pairs.second r)) - forFunction = - \val -> \fun -> case fun of - Core.FunctionElimination v0 -> - let re = forElimination val v0 - in (Pairs.first re, (Core.FunctionElimination (Pairs.second re))) - Core.FunctionLambda v0 -> - let rl = recurse val (Core.lambdaBody v0) - in (Pairs.first rl, (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.lambdaParameter v0), - Core.lambdaDomain = (Core.lambdaDomain v0), - Core.lambdaBody = (Pairs.second rl)}))) - _ -> (val, fun) - dflt = (val0, term0) - in case term0 of - Core.TermAnnotated v0 -> forSingle recurse (\t -> Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = t, - Core.annotatedTermAnnotation = (Core.annotatedTermAnnotation v0)})) val0 (Core.annotatedTermBody v0) - Core.TermApplication v0 -> - let rlhs = recurse val0 (Core.applicationFunction v0) - rrhs = recurse (Pairs.first rlhs) (Core.applicationArgument v0) - in (Pairs.first rrhs, (Core.TermApplication (Core.Application { - Core.applicationFunction = (Pairs.second rlhs), - Core.applicationArgument = (Pairs.second rrhs)}))) - Core.TermEither v0 -> Eithers.either (\l -> - let rl = recurse val0 l - in (Pairs.first rl, (Core.TermEither (Left (Pairs.second rl))))) (\r -> - let rr = recurse val0 r - in (Pairs.first rr, (Core.TermEither (Right (Pairs.second rr))))) v0 - Core.TermFunction v0 -> forSingle forFunction (\f -> Core.TermFunction f) val0 v0 - Core.TermLet v0 -> - let renv = recurse val0 (Core.letBody v0) - in (forMany forBinding (\bins -> Core.TermLet (Core.Let { - Core.letBindings = bins, - Core.letBody = (Pairs.second renv)})) (Pairs.first renv) (Core.letBindings v0)) - Core.TermList v0 -> forMany recurse (\x -> Core.TermList x) val0 v0 - Core.TermMap v0 -> forMany forPair (\pairs -> Core.TermMap (Maps.fromList pairs)) val0 (Maps.toList v0) - Core.TermMaybe v0 -> Maybes.maybe dflt (\t -> forSingle recurse (\t1 -> Core.TermMaybe (Just t1)) val0 t) v0 - Core.TermPair v0 -> - let rf = recurse val0 (Pairs.first v0) - rs = recurse (Pairs.first rf) (Pairs.second v0) - in (Pairs.first rs, (Core.TermPair (Pairs.second rf, (Pairs.second rs)))) - Core.TermRecord v0 -> forMany forField (\fields -> Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.recordTypeName v0), - Core.recordFields = fields})) val0 (Core.recordFields v0) - Core.TermSet v0 -> forMany recurse (\e -> Core.TermSet (Sets.fromList e)) val0 (Sets.toList v0) - Core.TermTypeApplication v0 -> forSingle recurse (\t -> Core.TermTypeApplication (Core.TypeApplicationTerm { - Core.typeApplicationTermBody = t, - Core.typeApplicationTermType = (Core.typeApplicationTermType v0)})) val0 (Core.typeApplicationTermBody v0) - Core.TermTypeLambda v0 -> forSingle recurse (\t -> Core.TermTypeLambda (Core.TypeLambda { - Core.typeLambdaParameter = (Core.typeLambdaParameter v0), - Core.typeLambdaBody = t})) val0 (Core.typeLambdaBody v0) - Core.TermUnion v0 -> forSingle recurse (\t -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.injectionTypeName v0), - Core.injectionField = Core.Field { - Core.fieldName = (Core.fieldName (Core.injectionField v0)), - Core.fieldTerm = t}})) val0 (Core.fieldTerm (Core.injectionField v0)) - Core.TermWrap v0 -> forSingle recurse (\t -> Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.wrappedTermTypeName v0), - Core.wrappedTermBody = t})) val0 (Core.wrappedTermBody v0) - _ -> dflt - recurse = f (fsub recurse) - in (recurse term0) - --- | Rewrite a term while folding to produce a value, with Graph updated as we descend into subterms. Combines the features of rewriteAndFoldTerm and rewriteTermWithGraph. The user function f receives a recurse function that handles subterm traversal and Graph management. -rewriteAndFoldTermWithGraph :: ((t0 -> Core.Term -> (t0, Core.Term)) -> Graph.Graph -> t0 -> Core.Term -> (t0, Core.Term)) -> Graph.Graph -> t0 -> Core.Term -> (t0, Core.Term) -rewriteAndFoldTermWithGraph f cx0 val0 term0 = - - let wrapper = - \lowLevelRecurse -> \valAndCx -> \term -> - let val = Pairs.first valAndCx - cx = Pairs.second valAndCx - cx1 = - case term of - Core.TermFunction v0 -> case v0 of - Core.FunctionLambda v1 -> extendGraphForLambda cx v1 - _ -> cx - Core.TermLet v0 -> extendGraphForLet (\_ -> \_ -> Nothing) cx v0 - Core.TermTypeLambda v0 -> extendGraphForTypeLambda cx v0 - _ -> cx - recurseForUser = - \newVal -> \subterm -> - let result = lowLevelRecurse (newVal, cx1) subterm - in (Pairs.first (Pairs.first result), (Pairs.second result)) - fResult = f recurseForUser cx1 val term - in ((Pairs.first fResult, cx), (Pairs.second fResult)) - result = rewriteAndFoldTerm wrapper (val0, cx0) term0 - in (Pairs.first (Pairs.first result), (Pairs.second result)) - --- | Rewrite a term while folding to produce a value, with both Graph and accessor path tracked. The path is a list of SubtermSteps representing the position from the root to the current term. Combines the features of rewriteAndFoldTermWithPath and Graph tracking. The Graph is automatically updated when descending into lambdas, lets, and type lambdas. -rewriteAndFoldTermWithGraphAndPath :: ((t0 -> Core.Term -> (t0, Core.Term)) -> [Paths.SubtermStep] -> Graph.Graph -> t0 -> Core.Term -> (t0, Core.Term)) -> Graph.Graph -> t0 -> Core.Term -> (t0, Core.Term) -rewriteAndFoldTermWithGraphAndPath f cx0 val0 term0 = - - let wrapper = - \recurse -> \path -> \cxAndVal -> \term -> - let cx = Pairs.first cxAndVal - val = Pairs.second cxAndVal - cx1 = - case term of - Core.TermFunction v0 -> case v0 of - Core.FunctionLambda v1 -> extendGraphForLambda cx v1 - _ -> cx - Core.TermLet v0 -> extendGraphForLet (\_ -> \_ -> Nothing) cx v0 - Core.TermTypeLambda v0 -> extendGraphForTypeLambda cx v0 - _ -> cx - recurseForUser = - \valIn -> \termIn -> - let result = recurse path (cx1, valIn) termIn - in (Pairs.second (Pairs.first result), (Pairs.second result)) - fResult = f recurseForUser path cx1 val term - in ((cx, (Pairs.first fResult)), (Pairs.second fResult)) - result = rewriteAndFoldTermWithPath wrapper (cx0, val0) term0 - in (Pairs.second (Pairs.first result), (Pairs.second result)) - --- | Rewrite a term with path tracking, and fold a function over it, accumulating a value. The path is a list of SubtermSteps from root to current position. -rewriteAndFoldTermWithPath :: (([Paths.SubtermStep] -> t0 -> Core.Term -> (t0, Core.Term)) -> [Paths.SubtermStep] -> t0 -> Core.Term -> (t0, Core.Term)) -> t0 -> Core.Term -> (t0, Core.Term) -rewriteAndFoldTermWithPath f term0 = - - let fsub = - \recurse -> \path -> \val0 -> \term0 -> - let forSingleWithAccessor = - \rec -> \cons -> \accessor -> \val -> \term -> - let r = rec (Lists.concat2 path [ - accessor]) val term - in (Pairs.first r, (cons (Pairs.second r))) - forManyWithAccessors = - \rec -> \cons -> \val -> \accessorTermPairs -> - let rr = - Lists.foldl (\r -> \atp -> - let r2 = rec (Lists.concat2 path [ - Pairs.first atp]) (Pairs.first r) (Pairs.second atp) - in (Pairs.first r2, (Lists.cons (Pairs.second r2) (Pairs.second r)))) (val, []) accessorTermPairs - in (Pairs.first rr, (cons (Lists.reverse (Pairs.second rr)))) - forFieldWithAccessor = - \mkAccessor -> \val -> \field -> - let r = recurse (Lists.concat2 path [ - mkAccessor (Core.fieldName field)]) val (Core.fieldTerm field) - in (Pairs.first r, Core.Field { - Core.fieldName = (Core.fieldName field), - Core.fieldTerm = (Pairs.second r)}) - forFieldsWithAccessor = - \mkAccessor -> forManyWithAccessors (\path1 -> \val1 -> \field1 -> forFieldWithAccessor mkAccessor val1 field1) (\x -> x) - forPairWithAccessors = - \keyAccessor -> \valAccessor -> \val -> \kv -> - let rk = recurse (Lists.concat2 path [ - keyAccessor]) val (Pairs.first kv) - rv = recurse (Lists.concat2 path [ - valAccessor]) (Pairs.first rk) (Pairs.second kv) - in (Pairs.first rv, (Pairs.second rk, (Pairs.second rv))) - forBindingWithAccessor = - \val -> \binding -> - let r = recurse (Lists.concat2 path [ - Paths.SubtermStepLetBinding (Core.bindingName binding)]) val (Core.bindingTerm binding) - in (Pairs.first r, Core.Binding { - Core.bindingName = (Core.bindingName binding), - Core.bindingTerm = (Pairs.second r), - Core.bindingType = (Core.bindingType binding)}) - forElimination = - \val -> \elm -> - let r = - case elm of - Core.EliminationUnion v0 -> - let rmd = - Maybes.map (\def -> recurse (Lists.concat2 path [ - Paths.SubtermStepUnionCasesDefault]) val def) (Core.caseStatementDefault v0) - val1 = Maybes.maybe val Pairs.first rmd - rcases = - forManyWithAccessors recurse (\x -> x) val1 (Lists.map (\f -> (Paths.SubtermStepUnionCasesBranch (Core.fieldName f), (Core.fieldTerm f))) (Core.caseStatementCases v0)) - in (Pairs.first rcases, (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.caseStatementTypeName v0), - Core.caseStatementDefault = (Maybes.map Pairs.second rmd), - Core.caseStatementCases = (Lists.map (\ft -> Core.Field { - Core.fieldName = (Pairs.first ft), - Core.fieldTerm = (Pairs.second ft)}) (Lists.zip (Lists.map Core.fieldName (Core.caseStatementCases v0)) (Pairs.second rcases)))}))) - _ -> (val, elm) - in (Pairs.first r, (Pairs.second r)) - forFunction = - \val -> \fun -> case fun of - Core.FunctionElimination v0 -> - let re = forElimination val v0 - in (Pairs.first re, (Core.FunctionElimination (Pairs.second re))) - Core.FunctionLambda v0 -> - let rl = recurse (Lists.concat2 path [ - Paths.SubtermStepLambdaBody]) val (Core.lambdaBody v0) - in (Pairs.first rl, (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.lambdaParameter v0), - Core.lambdaDomain = (Core.lambdaDomain v0), - Core.lambdaBody = (Pairs.second rl)}))) - _ -> (val, fun) - dflt = (val0, term0) - in case term0 of - Core.TermAnnotated v0 -> forSingleWithAccessor recurse (\t -> Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = t, - Core.annotatedTermAnnotation = (Core.annotatedTermAnnotation v0)})) Paths.SubtermStepAnnotatedBody val0 (Core.annotatedTermBody v0) - Core.TermApplication v0 -> - let rlhs = recurse (Lists.concat2 path [ - Paths.SubtermStepApplicationFunction]) val0 (Core.applicationFunction v0) - rrhs = recurse (Lists.concat2 path [ - Paths.SubtermStepApplicationArgument]) (Pairs.first rlhs) (Core.applicationArgument v0) - in (Pairs.first rrhs, (Core.TermApplication (Core.Application { - Core.applicationFunction = (Pairs.second rlhs), - Core.applicationArgument = (Pairs.second rrhs)}))) - Core.TermEither v0 -> Eithers.either (\l -> - let rl = recurse (Lists.concat2 path [ - Paths.SubtermStepSumTerm]) val0 l - in (Pairs.first rl, (Core.TermEither (Left (Pairs.second rl))))) (\r -> - let rr = recurse (Lists.concat2 path [ - Paths.SubtermStepSumTerm]) val0 r - in (Pairs.first rr, (Core.TermEither (Right (Pairs.second rr))))) v0 - Core.TermFunction v0 -> - let rf = forFunction val0 v0 - in (Pairs.first rf, (Core.TermFunction (Pairs.second rf))) - Core.TermLet v0 -> - let renv = recurse (Lists.concat2 path [ - Paths.SubtermStepLetBody]) val0 (Core.letBody v0) - rbindings = - Lists.foldl (\r -> \binding -> - let rb = forBindingWithAccessor (Pairs.first r) binding - in (Pairs.first rb, (Lists.cons (Pairs.second rb) (Pairs.second r)))) (Pairs.first renv, []) (Core.letBindings v0) - in (Pairs.first rbindings, (Core.TermLet (Core.Let { - Core.letBindings = (Lists.reverse (Pairs.second rbindings)), - Core.letBody = (Pairs.second renv)}))) - Core.TermList v0 -> - let idx = 0 - rr = - Lists.foldl (\r -> \el -> - let r2 = recurse (Lists.concat2 path [ - Paths.SubtermStepListElement (Pairs.first r)]) (Pairs.first (Pairs.second r)) el - in (Math.add (Pairs.first r) 1, (Pairs.first r2, (Lists.cons (Pairs.second r2) (Pairs.second (Pairs.second r)))))) (idx, (val0, [])) v0 - in (Pairs.first (Pairs.second rr), (Core.TermList (Lists.reverse (Pairs.second (Pairs.second rr))))) - Core.TermMap v0 -> - let idx = 0 - rr = - Lists.foldl (\r -> \kv -> - let rk = recurse (Lists.concat2 path [ - Paths.SubtermStepMapKey (Pairs.first r)]) (Pairs.first (Pairs.second r)) (Pairs.first kv) - rv = recurse (Lists.concat2 path [ - Paths.SubtermStepMapValue (Pairs.first r)]) (Pairs.first rk) (Pairs.second kv) - in (Math.add (Pairs.first r) 1, (Pairs.first rv, (Lists.cons (Pairs.second rk, (Pairs.second rv)) (Pairs.second (Pairs.second r)))))) (idx, (val0, [])) (Maps.toList v0) - in (Pairs.first (Pairs.second rr), (Core.TermMap (Maps.fromList (Lists.reverse (Pairs.second (Pairs.second rr)))))) - Core.TermMaybe v0 -> Maybes.maybe dflt (\t -> forSingleWithAccessor recurse (\t1 -> Core.TermMaybe (Just t1)) Paths.SubtermStepMaybeTerm val0 t) v0 - Core.TermPair v0 -> - let rf = recurse (Lists.concat2 path [ - Paths.SubtermStepProductTerm 0]) val0 (Pairs.first v0) - rs = recurse (Lists.concat2 path [ - Paths.SubtermStepProductTerm 1]) (Pairs.first rf) (Pairs.second v0) - in (Pairs.first rs, (Core.TermPair (Pairs.second rf, (Pairs.second rs)))) - Core.TermRecord v0 -> - let rfields = - forManyWithAccessors recurse (\x -> x) val0 (Lists.map (\f -> (Paths.SubtermStepRecordField (Core.fieldName f), (Core.fieldTerm f))) (Core.recordFields v0)) - in (Pairs.first rfields, (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.recordTypeName v0), - Core.recordFields = (Lists.map (\ft -> Core.Field { - Core.fieldName = (Pairs.first ft), - Core.fieldTerm = (Pairs.second ft)}) (Lists.zip (Lists.map Core.fieldName (Core.recordFields v0)) (Pairs.second rfields)))}))) - Core.TermSet v0 -> - let idx = 0 - rr = - Lists.foldl (\r -> \el -> - let r2 = recurse (Lists.concat2 path [ - Paths.SubtermStepSetElement (Pairs.first r)]) (Pairs.first (Pairs.second r)) el - in (Math.add (Pairs.first r) 1, (Pairs.first r2, (Lists.cons (Pairs.second r2) (Pairs.second (Pairs.second r)))))) (idx, (val0, [])) (Sets.toList v0) - in (Pairs.first (Pairs.second rr), (Core.TermSet (Sets.fromList (Lists.reverse (Pairs.second (Pairs.second rr)))))) - Core.TermTypeApplication v0 -> forSingleWithAccessor recurse (\t -> Core.TermTypeApplication (Core.TypeApplicationTerm { - Core.typeApplicationTermBody = t, - Core.typeApplicationTermType = (Core.typeApplicationTermType v0)})) Paths.SubtermStepTypeApplicationTerm val0 (Core.typeApplicationTermBody v0) - Core.TermTypeLambda v0 -> forSingleWithAccessor recurse (\t -> Core.TermTypeLambda (Core.TypeLambda { - Core.typeLambdaParameter = (Core.typeLambdaParameter v0), - Core.typeLambdaBody = t})) Paths.SubtermStepTypeLambdaBody val0 (Core.typeLambdaBody v0) - Core.TermUnion v0 -> forSingleWithAccessor recurse (\t -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.injectionTypeName v0), - Core.injectionField = Core.Field { - Core.fieldName = (Core.fieldName (Core.injectionField v0)), - Core.fieldTerm = t}})) Paths.SubtermStepInjectionTerm val0 (Core.fieldTerm (Core.injectionField v0)) - Core.TermWrap v0 -> forSingleWithAccessor recurse (\t -> Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.wrappedTermTypeName v0), - Core.wrappedTermBody = t})) Paths.SubtermStepWrappedTerm val0 (Core.wrappedTermBody v0) - _ -> dflt - recurse = f (fsub recurse) - in (recurse [] term0) - -rewriteTerm :: ((Core.Term -> Core.Term) -> Core.Term -> Core.Term) -> Core.Term -> Core.Term -rewriteTerm f term0 = - - let fsub = - \recurse -> \term -> - let forField = - \f -> Core.Field { - Core.fieldName = (Core.fieldName f), - Core.fieldTerm = (recurse (Core.fieldTerm f))} - forElimination = - \elm -> case elm of - Core.EliminationRecord v0 -> Core.EliminationRecord v0 - Core.EliminationUnion v0 -> Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.caseStatementTypeName v0), - Core.caseStatementDefault = (Maybes.map recurse (Core.caseStatementDefault v0)), - Core.caseStatementCases = (Lists.map forField (Core.caseStatementCases v0))}) - Core.EliminationWrap v0 -> Core.EliminationWrap v0 - forFunction = - \fun -> case fun of - Core.FunctionElimination v0 -> Core.FunctionElimination (forElimination v0) - Core.FunctionLambda v0 -> Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.lambdaParameter v0), - Core.lambdaDomain = (Core.lambdaDomain v0), - Core.lambdaBody = (recurse (Core.lambdaBody v0))}) - Core.FunctionPrimitive v0 -> Core.FunctionPrimitive v0 - forLet = - \lt -> - let mapBinding = - \b -> Core.Binding { - Core.bindingName = (Core.bindingName b), - Core.bindingTerm = (recurse (Core.bindingTerm b)), - Core.bindingType = (Core.bindingType b)} - in Core.Let { - Core.letBindings = (Lists.map mapBinding (Core.letBindings lt)), - Core.letBody = (recurse (Core.letBody lt))} - forMap = - \m -> - let forPair = \p -> (recurse (Pairs.first p), (recurse (Pairs.second p))) - in (Maps.fromList (Lists.map forPair (Maps.toList m))) - in case term of - Core.TermAnnotated v0 -> Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (recurse (Core.annotatedTermBody v0)), - Core.annotatedTermAnnotation = (Core.annotatedTermAnnotation v0)}) - Core.TermApplication v0 -> Core.TermApplication (Core.Application { - Core.applicationFunction = (recurse (Core.applicationFunction v0)), - Core.applicationArgument = (recurse (Core.applicationArgument v0))}) - Core.TermEither v0 -> Core.TermEither (Eithers.either (\l -> Left (recurse l)) (\r -> Right (recurse r)) v0) - Core.TermFunction v0 -> Core.TermFunction (forFunction v0) - Core.TermLet v0 -> Core.TermLet (forLet v0) - Core.TermList v0 -> Core.TermList (Lists.map recurse v0) - Core.TermLiteral v0 -> Core.TermLiteral v0 - Core.TermMap v0 -> Core.TermMap (forMap v0) - Core.TermMaybe v0 -> Core.TermMaybe (Maybes.map recurse v0) - Core.TermPair v0 -> Core.TermPair (recurse (Pairs.first v0), (recurse (Pairs.second v0))) - Core.TermRecord v0 -> Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.recordTypeName v0), - Core.recordFields = (Lists.map forField (Core.recordFields v0))}) - Core.TermSet v0 -> Core.TermSet (Sets.fromList (Lists.map recurse (Sets.toList v0))) - Core.TermTypeApplication v0 -> Core.TermTypeApplication (Core.TypeApplicationTerm { - Core.typeApplicationTermBody = (recurse (Core.typeApplicationTermBody v0)), - Core.typeApplicationTermType = (Core.typeApplicationTermType v0)}) - Core.TermTypeLambda v0 -> Core.TermTypeLambda (Core.TypeLambda { - Core.typeLambdaParameter = (Core.typeLambdaParameter v0), - Core.typeLambdaBody = (recurse (Core.typeLambdaBody v0))}) - Core.TermUnion v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.injectionTypeName v0), - Core.injectionField = (forField (Core.injectionField v0))}) - Core.TermUnit -> Core.TermUnit - Core.TermVariable v0 -> Core.TermVariable v0 - Core.TermWrap v0 -> Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.wrappedTermTypeName v0), - Core.wrappedTermBody = (recurse (Core.wrappedTermBody v0))}) - recurse = f (fsub recurse) - in (recurse term0) - --- | Either-based term rewriting with custom transformation function -rewriteTermM :: ((Core.Term -> Either t0 Core.Term) -> Core.Term -> Either t0 Core.Term) -> Core.Term -> Either t0 Core.Term -rewriteTermM f term0 = - - let fsub = - \recurse -> \term -> - let forField = - \field -> Eithers.bind (recurse (Core.fieldTerm field)) (\t -> Right (Core.Field { - Core.fieldName = (Core.fieldName field), - Core.fieldTerm = t})) - forPair = - \kv -> Eithers.bind (recurse (Pairs.first kv)) (\k -> Eithers.bind (recurse (Pairs.second kv)) (\v -> Right (k, v))) - mapBinding = - \b -> Eithers.bind (recurse (Core.bindingTerm b)) (\v -> Right (Core.Binding { - Core.bindingName = (Core.bindingName b), - Core.bindingTerm = v, - Core.bindingType = (Core.bindingType b)})) - in case term of - Core.TermAnnotated v0 -> Eithers.bind (recurse (Core.annotatedTermBody v0)) (\ex -> Right (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = ex, - Core.annotatedTermAnnotation = (Core.annotatedTermAnnotation v0)}))) - Core.TermApplication v0 -> Eithers.bind (recurse (Core.applicationFunction v0)) (\lhs -> Eithers.bind (recurse (Core.applicationArgument v0)) (\rhs -> Right (Core.TermApplication (Core.Application { - Core.applicationFunction = lhs, - Core.applicationArgument = rhs})))) - Core.TermEither v0 -> Eithers.bind (Eithers.either (\l -> Eithers.map (\x -> Left x) (recurse l)) (\r -> Eithers.map (\x -> Right x) (recurse r)) v0) (\re -> Right (Core.TermEither re)) - Core.TermFunction v0 -> - let forElm = - \e -> case e of - Core.EliminationRecord v1 -> Right (Core.FunctionElimination (Core.EliminationRecord v1)) - Core.EliminationUnion v1 -> - let n = Core.caseStatementTypeName v1 - def = Core.caseStatementDefault v1 - cases = Core.caseStatementCases v1 - in (Eithers.bind (Maybes.maybe (Right Nothing) (\t -> Eithers.map Maybes.pure (recurse t)) def) (\rdef -> Eithers.map (\rcases -> Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = n, - Core.caseStatementDefault = rdef, - Core.caseStatementCases = rcases}))) (Eithers.mapList forField cases))) - Core.EliminationWrap v1 -> Right (Core.FunctionElimination (Core.EliminationWrap v1)) - forFun = - \fun -> case fun of - Core.FunctionElimination v1 -> forElm v1 - Core.FunctionLambda v1 -> - let v = Core.lambdaParameter v1 - d = Core.lambdaDomain v1 - body = Core.lambdaBody v1 - in (Eithers.bind (recurse body) (\rbody -> Right (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = v, - Core.lambdaDomain = d, - Core.lambdaBody = rbody})))) - Core.FunctionPrimitive v1 -> Right (Core.FunctionPrimitive v1) - in (Eithers.bind (forFun v0) (\rfun -> Right (Core.TermFunction rfun))) - Core.TermLet v0 -> - let bindings = Core.letBindings v0 - env = Core.letBody v0 - in (Eithers.bind (Eithers.mapList mapBinding bindings) (\rbindings -> Eithers.bind (recurse env) (\renv -> Right (Core.TermLet (Core.Let { - Core.letBindings = rbindings, - Core.letBody = renv}))))) - Core.TermList v0 -> Eithers.bind (Eithers.mapList recurse v0) (\rels -> Right (Core.TermList rels)) - Core.TermLiteral v0 -> Right (Core.TermLiteral v0) - Core.TermMap v0 -> Eithers.bind (Eithers.mapList forPair (Maps.toList v0)) (\pairs -> Right (Core.TermMap (Maps.fromList pairs))) - Core.TermMaybe v0 -> Eithers.bind (Eithers.mapMaybe recurse v0) (\rm -> Right (Core.TermMaybe rm)) - Core.TermPair v0 -> Eithers.bind (recurse (Pairs.first v0)) (\rf -> Eithers.bind (recurse (Pairs.second v0)) (\rs -> Right (Core.TermPair (rf, rs)))) - Core.TermRecord v0 -> - let n = Core.recordTypeName v0 - fields = Core.recordFields v0 - in (Eithers.map (\rfields -> Core.TermRecord (Core.Record { - Core.recordTypeName = n, - Core.recordFields = rfields})) (Eithers.mapList forField fields)) - Core.TermSet v0 -> Eithers.bind (Eithers.mapList recurse (Sets.toList v0)) (\rlist -> Right (Core.TermSet (Sets.fromList rlist))) - Core.TermTypeApplication v0 -> Eithers.bind (recurse (Core.typeApplicationTermBody v0)) (\t -> Right (Core.TermTypeApplication (Core.TypeApplicationTerm { - Core.typeApplicationTermBody = t, - Core.typeApplicationTermType = (Core.typeApplicationTermType v0)}))) - Core.TermTypeLambda v0 -> - let v = Core.typeLambdaParameter v0 - body = Core.typeLambdaBody v0 - in (Eithers.bind (recurse body) (\rbody -> Right (Core.TermTypeLambda (Core.TypeLambda { - Core.typeLambdaParameter = v, - Core.typeLambdaBody = rbody})))) - Core.TermUnion v0 -> - let n = Core.injectionTypeName v0 - field = Core.injectionField v0 - in (Eithers.map (\rfield -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = n, - Core.injectionField = rfield})) (forField field)) - Core.TermUnit -> Right Core.TermUnit - Core.TermVariable v0 -> Right (Core.TermVariable v0) - Core.TermWrap v0 -> - let name = Core.wrappedTermTypeName v0 - t = Core.wrappedTermBody v0 - in (Eithers.bind (recurse t) (\rt -> Right (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = name, - Core.wrappedTermBody = rt})))) - recurse = f (fsub recurse) - in (recurse term0) - --- | A variant of rewriteTerm which allows a context (e.g. a TypeContext) to be passed down to all subterms during rewriting -rewriteTermWithContext :: ((t0 -> Core.Term -> Core.Term) -> t0 -> Core.Term -> Core.Term) -> t0 -> Core.Term -> Core.Term -rewriteTermWithContext f cx0 term0 = - - let forSubterms = - \recurse0 -> \cx -> \term -> - let recurse = recurse0 cx - forField = - \field -> Core.Field { - Core.fieldName = (Core.fieldName field), - Core.fieldTerm = (recurse (Core.fieldTerm field))} - forElimination = - \elm -> case elm of - Core.EliminationRecord v0 -> Core.EliminationRecord v0 - Core.EliminationUnion v0 -> Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.caseStatementTypeName v0), - Core.caseStatementDefault = (Maybes.map recurse (Core.caseStatementDefault v0)), - Core.caseStatementCases = (Lists.map forField (Core.caseStatementCases v0))}) - Core.EliminationWrap v0 -> Core.EliminationWrap v0 - forFunction = - \fun -> case fun of - Core.FunctionElimination v0 -> Core.FunctionElimination (forElimination v0) - Core.FunctionLambda v0 -> Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.lambdaParameter v0), - Core.lambdaDomain = (Core.lambdaDomain v0), - Core.lambdaBody = (recurse (Core.lambdaBody v0))}) - Core.FunctionPrimitive v0 -> Core.FunctionPrimitive v0 - forLet = - \lt -> - let mapBinding = - \b -> Core.Binding { - Core.bindingName = (Core.bindingName b), - Core.bindingTerm = (recurse (Core.bindingTerm b)), - Core.bindingType = (Core.bindingType b)} - in Core.Let { - Core.letBindings = (Lists.map mapBinding (Core.letBindings lt)), - Core.letBody = (recurse (Core.letBody lt))} - forMap = - \m -> - let forPair = \p -> (recurse (Pairs.first p), (recurse (Pairs.second p))) - in (Maps.fromList (Lists.map forPair (Maps.toList m))) - in case term of - Core.TermAnnotated v0 -> Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (recurse (Core.annotatedTermBody v0)), - Core.annotatedTermAnnotation = (Core.annotatedTermAnnotation v0)}) - Core.TermApplication v0 -> Core.TermApplication (Core.Application { - Core.applicationFunction = (recurse (Core.applicationFunction v0)), - Core.applicationArgument = (recurse (Core.applicationArgument v0))}) - Core.TermEither v0 -> Core.TermEither (Eithers.either (\l -> Left (recurse l)) (\r -> Right (recurse r)) v0) - Core.TermFunction v0 -> Core.TermFunction (forFunction v0) - Core.TermLet v0 -> Core.TermLet (forLet v0) - Core.TermList v0 -> Core.TermList (Lists.map recurse v0) - Core.TermLiteral v0 -> Core.TermLiteral v0 - Core.TermMap v0 -> Core.TermMap (forMap v0) - Core.TermMaybe v0 -> Core.TermMaybe (Maybes.map recurse v0) - Core.TermPair v0 -> Core.TermPair (recurse (Pairs.first v0), (recurse (Pairs.second v0))) - Core.TermRecord v0 -> Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.recordTypeName v0), - Core.recordFields = (Lists.map forField (Core.recordFields v0))}) - Core.TermSet v0 -> Core.TermSet (Sets.fromList (Lists.map recurse (Sets.toList v0))) - Core.TermTypeApplication v0 -> Core.TermTypeApplication (Core.TypeApplicationTerm { - Core.typeApplicationTermBody = (recurse (Core.typeApplicationTermBody v0)), - Core.typeApplicationTermType = (Core.typeApplicationTermType v0)}) - Core.TermTypeLambda v0 -> Core.TermTypeLambda (Core.TypeLambda { - Core.typeLambdaParameter = (Core.typeLambdaParameter v0), - Core.typeLambdaBody = (recurse (Core.typeLambdaBody v0))}) - Core.TermUnion v0 -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.injectionTypeName v0), - Core.injectionField = (forField (Core.injectionField v0))}) - Core.TermUnit -> Core.TermUnit - Core.TermVariable v0 -> Core.TermVariable v0 - Core.TermWrap v0 -> Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.wrappedTermTypeName v0), - Core.wrappedTermBody = (recurse (Core.wrappedTermBody v0))}) - rewrite = \cx -> \term -> f (forSubterms rewrite) cx term - in (rewrite cx0 term0) - --- | Either-based variant of rewriteTermWithContextM which allows a context (e.g. a TypeContext) to be passed down to all subterms during rewriting -rewriteTermWithContextM :: ((t0 -> Core.Term -> Either t1 Core.Term) -> t0 -> Core.Term -> Either t1 Core.Term) -> t0 -> Core.Term -> Either t1 Core.Term -rewriteTermWithContextM f cx0 term0 = - - let forSubterms = - \recurse0 -> \cx -> \term -> - let recurse = recurse0 cx - forField = - \field -> Eithers.bind (recurse (Core.fieldTerm field)) (\t -> Right (Core.Field { - Core.fieldName = (Core.fieldName field), - Core.fieldTerm = t})) - forPair = - \kv -> Eithers.bind (recurse (Pairs.first kv)) (\k -> Eithers.bind (recurse (Pairs.second kv)) (\v -> Right (k, v))) - forElimination = - \e -> case e of - Core.EliminationRecord v0 -> Right (Core.FunctionElimination (Core.EliminationRecord v0)) - Core.EliminationUnion v0 -> - let n = Core.caseStatementTypeName v0 - def = Core.caseStatementDefault v0 - cases = Core.caseStatementCases v0 - in (Eithers.bind (Maybes.maybe (Right Nothing) (\t -> Eithers.map Maybes.pure (recurse t)) def) (\rdef -> Eithers.map (\rcases -> Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = n, - Core.caseStatementDefault = rdef, - Core.caseStatementCases = rcases}))) (Eithers.mapList forField cases))) - Core.EliminationWrap v0 -> Right (Core.FunctionElimination (Core.EliminationWrap v0)) - forFunction = - \fun -> case fun of - Core.FunctionElimination v0 -> forElimination v0 - Core.FunctionLambda v0 -> - let v = Core.lambdaParameter v0 - d = Core.lambdaDomain v0 - body = Core.lambdaBody v0 - in (Eithers.bind (recurse body) (\rbody -> Right (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = v, - Core.lambdaDomain = d, - Core.lambdaBody = rbody})))) - Core.FunctionPrimitive v0 -> Right (Core.FunctionPrimitive v0) - mapBinding = - \b -> Eithers.bind (recurse (Core.bindingTerm b)) (\v -> Right (Core.Binding { - Core.bindingName = (Core.bindingName b), - Core.bindingTerm = v, - Core.bindingType = (Core.bindingType b)})) - in case term of - Core.TermAnnotated v0 -> Eithers.bind (recurse (Core.annotatedTermBody v0)) (\ex -> Right (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = ex, - Core.annotatedTermAnnotation = (Core.annotatedTermAnnotation v0)}))) - Core.TermApplication v0 -> Eithers.bind (recurse (Core.applicationFunction v0)) (\lhs -> Eithers.bind (recurse (Core.applicationArgument v0)) (\rhs -> Right (Core.TermApplication (Core.Application { - Core.applicationFunction = lhs, - Core.applicationArgument = rhs})))) - Core.TermEither v0 -> Eithers.bind (Eithers.either (\l -> Eithers.map (\x -> Left x) (recurse l)) (\r -> Eithers.map (\x -> Right x) (recurse r)) v0) (\re -> Right (Core.TermEither re)) - Core.TermFunction v0 -> Eithers.bind (forFunction v0) (\rfun -> Right (Core.TermFunction rfun)) - Core.TermLet v0 -> - let bindings = Core.letBindings v0 - body = Core.letBody v0 - in (Eithers.bind (Eithers.mapList mapBinding bindings) (\rbindings -> Eithers.bind (recurse body) (\rbody -> Right (Core.TermLet (Core.Let { - Core.letBindings = rbindings, - Core.letBody = rbody}))))) - Core.TermList v0 -> Eithers.bind (Eithers.mapList recurse v0) (\rels -> Right (Core.TermList rels)) - Core.TermLiteral v0 -> Right (Core.TermLiteral v0) - Core.TermMap v0 -> Eithers.bind (Eithers.mapList forPair (Maps.toList v0)) (\pairs -> Right (Core.TermMap (Maps.fromList pairs))) - Core.TermMaybe v0 -> Eithers.bind (Eithers.mapMaybe recurse v0) (\rm -> Right (Core.TermMaybe rm)) - Core.TermPair v0 -> Eithers.bind (recurse (Pairs.first v0)) (\rfirst -> Eithers.bind (recurse (Pairs.second v0)) (\rsecond -> Right (Core.TermPair (rfirst, rsecond)))) - Core.TermRecord v0 -> - let n = Core.recordTypeName v0 - fields = Core.recordFields v0 - in (Eithers.map (\rfields -> Core.TermRecord (Core.Record { - Core.recordTypeName = n, - Core.recordFields = rfields})) (Eithers.mapList forField fields)) - Core.TermSet v0 -> Eithers.bind (Eithers.mapList recurse (Sets.toList v0)) (\rlist -> Right (Core.TermSet (Sets.fromList rlist))) - Core.TermTypeApplication v0 -> Eithers.bind (recurse (Core.typeApplicationTermBody v0)) (\t -> Right (Core.TermTypeApplication (Core.TypeApplicationTerm { - Core.typeApplicationTermBody = t, - Core.typeApplicationTermType = (Core.typeApplicationTermType v0)}))) - Core.TermTypeLambda v0 -> - let v = Core.typeLambdaParameter v0 - body = Core.typeLambdaBody v0 - in (Eithers.bind (recurse body) (\rbody -> Right (Core.TermTypeLambda (Core.TypeLambda { - Core.typeLambdaParameter = v, - Core.typeLambdaBody = rbody})))) - Core.TermUnion v0 -> - let n = Core.injectionTypeName v0 - field = Core.injectionField v0 - in (Eithers.map (\rfield -> Core.TermUnion (Core.Injection { - Core.injectionTypeName = n, - Core.injectionField = rfield})) (forField field)) - Core.TermUnit -> Right Core.TermUnit - Core.TermVariable v0 -> Right (Core.TermVariable v0) - Core.TermWrap v0 -> - let name = Core.wrappedTermTypeName v0 - t = Core.wrappedTermBody v0 - in (Eithers.bind (recurse t) (\rt -> Right (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = name, - Core.wrappedTermBody = rt})))) - rewrite = \cx -> \term -> f (forSubterms rewrite) cx term - in (rewrite cx0 term0) - --- | Rewrite a term with the help of a Graph which is updated as we descend into subterms -rewriteTermWithGraph :: ((Core.Term -> t0) -> Graph.Graph -> Core.Term -> t0) -> Graph.Graph -> Core.Term -> t0 -rewriteTermWithGraph f cx0 term0 = - - let f2 = - \recurse -> \cx -> \term -> - let recurse1 = \term -> recurse cx term - in case term of - Core.TermFunction v0 -> case v0 of - Core.FunctionLambda v1 -> - let cx1 = extendGraphForLambda cx v1 - recurse2 = \term -> recurse cx1 term - in (f recurse2 cx1 term) - _ -> f recurse1 cx term - Core.TermLet v0 -> - let cx1 = extendGraphForLet (\_ -> \_ -> Nothing) cx v0 - recurse2 = \term -> recurse cx1 term - in (f recurse2 cx1 term) - Core.TermTypeLambda v0 -> - let cx1 = extendGraphForTypeLambda cx v0 - recurse2 = \term -> recurse cx1 term - in (f recurse2 cx1 term) - _ -> f recurse1 cx term - rewrite = \cx -> \term -> f2 rewrite cx term - in (rewrite cx0 term0) - -rewriteType :: ((Core.Type -> Core.Type) -> Core.Type -> Core.Type) -> Core.Type -> Core.Type -rewriteType f typ0 = - - let fsub = - \recurse -> \typ -> - let forField = - \field -> Core.FieldType { - Core.fieldTypeName = (Core.fieldTypeName field), - Core.fieldTypeType = (recurse (Core.fieldTypeType field))} - in case typ of - Core.TypeAnnotated v0 -> Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = (recurse (Core.annotatedTypeBody v0)), - Core.annotatedTypeAnnotation = (Core.annotatedTypeAnnotation v0)}) - Core.TypeApplication v0 -> Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (recurse (Core.applicationTypeFunction v0)), - Core.applicationTypeArgument = (recurse (Core.applicationTypeArgument v0))}) - Core.TypeEither v0 -> Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (recurse (Core.eitherTypeLeft v0)), - Core.eitherTypeRight = (recurse (Core.eitherTypeRight v0))}) - Core.TypePair v0 -> Core.TypePair (Core.PairType { - Core.pairTypeFirst = (recurse (Core.pairTypeFirst v0)), - Core.pairTypeSecond = (recurse (Core.pairTypeSecond v0))}) - Core.TypeFunction v0 -> Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (recurse (Core.functionTypeDomain v0)), - Core.functionTypeCodomain = (recurse (Core.functionTypeCodomain v0))}) - Core.TypeForall v0 -> Core.TypeForall (Core.ForallType { - Core.forallTypeParameter = (Core.forallTypeParameter v0), - Core.forallTypeBody = (recurse (Core.forallTypeBody v0))}) - Core.TypeList v0 -> Core.TypeList (recurse v0) - Core.TypeLiteral v0 -> Core.TypeLiteral v0 - Core.TypeMap v0 -> Core.TypeMap (Core.MapType { - Core.mapTypeKeys = (recurse (Core.mapTypeKeys v0)), - Core.mapTypeValues = (recurse (Core.mapTypeValues v0))}) - Core.TypeMaybe v0 -> Core.TypeMaybe (recurse v0) - Core.TypeRecord v0 -> Core.TypeRecord (Lists.map forField v0) - Core.TypeSet v0 -> Core.TypeSet (recurse v0) - Core.TypeUnion v0 -> Core.TypeUnion (Lists.map forField v0) - Core.TypeUnit -> Core.TypeUnit - Core.TypeVariable v0 -> Core.TypeVariable v0 - Core.TypeVoid -> Core.TypeVoid - Core.TypeWrap v0 -> Core.TypeWrap (recurse v0) - recurse = f (fsub recurse) - in (recurse typ0) - --- | Either-based type rewriting -rewriteTypeM :: ((Core.Type -> Either t0 Core.Type) -> Core.Type -> Either t0 Core.Type) -> Core.Type -> Either t0 Core.Type -rewriteTypeM f typ0 = - - let fsub = - \recurse -> \typ -> case typ of - Core.TypeAnnotated v0 -> Eithers.bind (recurse (Core.annotatedTypeBody v0)) (\t -> Right (Core.TypeAnnotated (Core.AnnotatedType { - Core.annotatedTypeBody = t, - Core.annotatedTypeAnnotation = (Core.annotatedTypeAnnotation v0)}))) - Core.TypeApplication v0 -> Eithers.bind (recurse (Core.applicationTypeFunction v0)) (\lhs -> Eithers.bind (recurse (Core.applicationTypeArgument v0)) (\rhs -> Right (Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = lhs, - Core.applicationTypeArgument = rhs})))) - Core.TypeEither v0 -> Eithers.bind (recurse (Core.eitherTypeLeft v0)) (\left -> Eithers.bind (recurse (Core.eitherTypeRight v0)) (\right -> Right (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = left, - Core.eitherTypeRight = right})))) - Core.TypePair v0 -> Eithers.bind (recurse (Core.pairTypeFirst v0)) (\pairFirst -> Eithers.bind (recurse (Core.pairTypeSecond v0)) (\pairSecond -> Right (Core.TypePair (Core.PairType { - Core.pairTypeFirst = pairFirst, - Core.pairTypeSecond = pairSecond})))) - Core.TypeFunction v0 -> Eithers.bind (recurse (Core.functionTypeDomain v0)) (\dom -> Eithers.bind (recurse (Core.functionTypeCodomain v0)) (\cod -> Right (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = dom, - Core.functionTypeCodomain = cod})))) - Core.TypeForall v0 -> Eithers.bind (recurse (Core.forallTypeBody v0)) (\b -> Right (Core.TypeForall (Core.ForallType { - Core.forallTypeParameter = (Core.forallTypeParameter v0), - Core.forallTypeBody = b}))) - Core.TypeList v0 -> Eithers.bind (recurse v0) (\rt -> Right (Core.TypeList rt)) - Core.TypeLiteral v0 -> Right (Core.TypeLiteral v0) - Core.TypeMap v0 -> Eithers.bind (recurse (Core.mapTypeKeys v0)) (\kt -> Eithers.bind (recurse (Core.mapTypeValues v0)) (\vt -> Right (Core.TypeMap (Core.MapType { - Core.mapTypeKeys = kt, - Core.mapTypeValues = vt})))) - Core.TypeMaybe v0 -> Eithers.bind (recurse v0) (\rt -> Right (Core.TypeMaybe rt)) - Core.TypeRecord v0 -> - let forField = - \f -> Eithers.bind (recurse (Core.fieldTypeType f)) (\t -> Right (Core.FieldType { - Core.fieldTypeName = (Core.fieldTypeName f), - Core.fieldTypeType = t})) - in (Eithers.bind (Eithers.mapList forField v0) (\rfields -> Right (Core.TypeRecord rfields))) - Core.TypeSet v0 -> Eithers.bind (recurse v0) (\rt -> Right (Core.TypeSet rt)) - Core.TypeUnion v0 -> - let forField = - \f -> Eithers.bind (recurse (Core.fieldTypeType f)) (\t -> Right (Core.FieldType { - Core.fieldTypeName = (Core.fieldTypeName f), - Core.fieldTypeType = t})) - in (Eithers.bind (Eithers.mapList forField v0) (\rfields -> Right (Core.TypeUnion rfields))) - Core.TypeUnit -> Right Core.TypeUnit - Core.TypeVariable v0 -> Right (Core.TypeVariable v0) - Core.TypeVoid -> Right Core.TypeVoid - Core.TypeWrap v0 -> Eithers.bind (recurse v0) (\t -> Right (Core.TypeWrap t)) - recurse = f (fsub recurse) - in (recurse typ0) - --- | Simplify terms by applying beta reduction where possible -simplifyTerm :: Core.Term -> Core.Term -simplifyTerm term = - - let simplify = - \recurse -> \term -> - let forRhs = - \rhs -> \var -> \body -> case (deannotateTerm rhs) of - Core.TermVariable v0 -> simplifyTerm (substituteVariable var v0 body) - _ -> term - forLhs = - \lhs -> \rhs -> - let forFun = - \fun -> case fun of - Core.FunctionLambda v0 -> - let var = Core.lambdaParameter v0 - body = Core.lambdaBody v0 - in (Logic.ifElse (Sets.member var (freeVariablesInTerm body)) (forRhs rhs var body) (simplifyTerm body)) - _ -> term - in case (deannotateTerm lhs) of - Core.TermFunction v0 -> forFun v0 - _ -> term - forTerm = - \stripped -> case stripped of - Core.TermApplication v0 -> - let lhs = Core.applicationFunction v0 - rhs = Core.applicationArgument v0 - in (forLhs lhs rhs) - _ -> term - stripped = deannotateTerm term - in (recurse (forTerm stripped)) - in (rewriteTerm simplify term) - --- | Strip outer type lambda wrappers from a term, preserving type application wrappers and annotations -stripTypeLambdas :: Core.Term -> Core.Term -stripTypeLambdas t = - case t of - Core.TermAnnotated v0 -> - let subj = Core.annotatedTermBody v0 - ann = Core.annotatedTermAnnotation v0 - in (Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (stripTypeLambdas subj), - Core.annotatedTermAnnotation = ann})) - Core.TermTypeLambda v0 -> stripTypeLambdas (Core.typeLambdaBody v0) - _ -> t - --- | Substitute type variables in a type -substituteTypeVariables :: M.Map Core.Name Core.Name -> Core.Type -> Core.Type -substituteTypeVariables subst typ = - - let replace = - \recurse -> \typ -> case typ of - Core.TypeVariable v0 -> Core.TypeVariable (Maybes.fromMaybe v0 (Maps.lookup v0 subst)) - _ -> recurse typ - in (rewriteType replace typ) - --- | Substitute type variables throughout a term, including in type annotations, type applications, lambda domains, and type schemes -substituteTypeVariablesInTerm :: M.Map Core.Name Core.Name -> Core.Term -> Core.Term -substituteTypeVariablesInTerm subst term = - - let st = substituteTypeVariables subst - stOpt = \mt -> Maybes.map st mt - stScheme = - \ts -> Core.TypeScheme { - Core.typeSchemeVariables = (Core.typeSchemeVariables ts), - Core.typeSchemeType = (st (Core.typeSchemeType ts)), - Core.typeSchemeConstraints = (Core.typeSchemeConstraints ts)} - stSchemeOpt = \mts -> Maybes.map stScheme mts - replace = - \recurse -> \t -> case t of - Core.TermFunction v0 -> case v0 of - Core.FunctionLambda v1 -> Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.lambdaParameter v1), - Core.lambdaDomain = (stOpt (Core.lambdaDomain v1)), - Core.lambdaBody = (recurse (Core.lambdaBody v1))})) - _ -> recurse t - Core.TermLet v0 -> - let mapBinding = - \b -> Core.Binding { - Core.bindingName = (Core.bindingName b), - Core.bindingTerm = (recurse (Core.bindingTerm b)), - Core.bindingType = (stSchemeOpt (Core.bindingType b))} - in (Core.TermLet (Core.Let { - Core.letBindings = (Lists.map mapBinding (Core.letBindings v0)), - Core.letBody = (recurse (Core.letBody v0))})) - Core.TermTypeApplication v0 -> Core.TermTypeApplication (Core.TypeApplicationTerm { - Core.typeApplicationTermBody = (recurse (Core.typeApplicationTermBody v0)), - Core.typeApplicationTermType = (st (Core.typeApplicationTermType v0))}) - Core.TermTypeLambda v0 -> Core.TermTypeLambda (Core.TypeLambda { - Core.typeLambdaParameter = (Maybes.fromMaybe (Core.typeLambdaParameter v0) (Maps.lookup (Core.typeLambdaParameter v0) subst)), - Core.typeLambdaBody = (recurse (Core.typeLambdaBody v0))}) - Core.TermAnnotated v0 -> Core.TermAnnotated (Core.AnnotatedTerm { - Core.annotatedTermBody = (recurse (Core.annotatedTermBody v0)), - Core.annotatedTermAnnotation = (Core.annotatedTermAnnotation v0)}) - _ -> recurse t - in (rewriteTerm replace term) - --- | Substitute one variable for another in a term -substituteVariable :: Core.Name -> Core.Name -> Core.Term -> Core.Term -substituteVariable from to term = - - let replace = - \recurse -> \term -> case term of - Core.TermVariable v0 -> Core.TermVariable (Logic.ifElse (Equality.equal v0 from) to v0) - Core.TermFunction v0 -> case v0 of - Core.FunctionLambda v1 -> Logic.ifElse (Equality.equal (Core.lambdaParameter v1) from) term (recurse term) - _ -> recurse term - _ -> recurse term - in (rewriteTerm replace term) - --- | Substitute multiple variables in a term -substituteVariables :: M.Map Core.Name Core.Name -> Core.Term -> Core.Term -substituteVariables subst term = - - let replace = - \recurse -> \term -> case term of - Core.TermVariable v0 -> Core.TermVariable (Maybes.fromMaybe v0 (Maps.lookup v0 subst)) - Core.TermFunction v0 -> case v0 of - Core.FunctionLambda v1 -> Maybes.maybe (recurse term) (\_ -> term) (Maps.lookup (Core.lambdaParameter v1) subst) - _ -> recurse term - _ -> recurse term - in (rewriteTerm replace term) - --- | Find the children of a given term -subterms :: Core.Term -> [Core.Term] -subterms x = - case x of - Core.TermAnnotated v0 -> [ - Core.annotatedTermBody v0] - Core.TermApplication v0 -> [ - Core.applicationFunction v0, - (Core.applicationArgument v0)] - Core.TermEither v0 -> Eithers.either (\l -> [ - l]) (\r -> [ - r]) v0 - Core.TermFunction v0 -> case v0 of - Core.FunctionElimination v1 -> case v1 of - Core.EliminationUnion v2 -> Lists.concat2 (Maybes.maybe [] (\t -> [ - t]) (Core.caseStatementDefault v2)) (Lists.map Core.fieldTerm (Core.caseStatementCases v2)) - _ -> [] - Core.FunctionLambda v1 -> [ - Core.lambdaBody v1] - _ -> [] - Core.TermLet v0 -> Lists.cons (Core.letBody v0) (Lists.map Core.bindingTerm (Core.letBindings v0)) - Core.TermList v0 -> v0 - Core.TermLiteral _ -> [] - Core.TermMap v0 -> Lists.concat (Lists.map (\p -> [ - Pairs.first p, - (Pairs.second p)]) (Maps.toList v0)) - Core.TermMaybe v0 -> Maybes.maybe [] (\t -> [ - t]) v0 - Core.TermPair v0 -> [ - Pairs.first v0, - (Pairs.second v0)] - Core.TermRecord v0 -> Lists.map Core.fieldTerm (Core.recordFields v0) - Core.TermSet v0 -> Sets.toList v0 - Core.TermTypeApplication v0 -> [ - Core.typeApplicationTermBody v0] - Core.TermTypeLambda v0 -> [ - Core.typeLambdaBody v0] - Core.TermUnion v0 -> [ - Core.fieldTerm (Core.injectionField v0)] - Core.TermUnit -> [] - Core.TermVariable _ -> [] - Core.TermWrap v0 -> [ - Core.wrappedTermBody v0] - --- | Find the children of a given term -subtermsWithSteps :: Core.Term -> [(Paths.SubtermStep, Core.Term)] -subtermsWithSteps x = - case x of - Core.TermAnnotated v0 -> [ - (Paths.SubtermStepAnnotatedBody, (Core.annotatedTermBody v0))] - Core.TermApplication v0 -> [ - (Paths.SubtermStepApplicationFunction, (Core.applicationFunction v0)), - (Paths.SubtermStepApplicationArgument, (Core.applicationArgument v0))] - Core.TermEither _ -> [] - Core.TermFunction v0 -> case v0 of - Core.FunctionElimination v1 -> case v1 of - Core.EliminationUnion v2 -> Lists.concat2 (Maybes.maybe [] (\t -> [ - (Paths.SubtermStepUnionCasesDefault, t)]) (Core.caseStatementDefault v2)) (Lists.map (\f -> (Paths.SubtermStepUnionCasesBranch (Core.fieldName f), (Core.fieldTerm f))) (Core.caseStatementCases v2)) - _ -> [] - Core.FunctionLambda v1 -> [ - (Paths.SubtermStepLambdaBody, (Core.lambdaBody v1))] - _ -> [] - Core.TermLet v0 -> Lists.cons (Paths.SubtermStepLetBody, (Core.letBody v0)) (Lists.map (\b -> (Paths.SubtermStepLetBinding (Core.bindingName b), (Core.bindingTerm b))) (Core.letBindings v0)) - Core.TermList v0 -> Lists.map (\e -> (Paths.SubtermStepListElement 0, e)) v0 - Core.TermLiteral _ -> [] - Core.TermMap v0 -> Lists.concat (Lists.map (\p -> [ - (Paths.SubtermStepMapKey 0, (Pairs.first p)), - (Paths.SubtermStepMapValue 0, (Pairs.second p))]) (Maps.toList v0)) - Core.TermMaybe v0 -> Maybes.maybe [] (\t -> [ - (Paths.SubtermStepMaybeTerm, t)]) v0 - Core.TermPair _ -> [] - Core.TermRecord v0 -> Lists.map (\f -> (Paths.SubtermStepRecordField (Core.fieldName f), (Core.fieldTerm f))) (Core.recordFields v0) - Core.TermSet v0 -> Lists.map (\e -> (Paths.SubtermStepListElement 0, e)) (Sets.toList v0) - Core.TermTypeApplication v0 -> [ - (Paths.SubtermStepTypeApplicationTerm, (Core.typeApplicationTermBody v0))] - Core.TermTypeLambda v0 -> [ - (Paths.SubtermStepTypeLambdaBody, (Core.typeLambdaBody v0))] - Core.TermUnion v0 -> [ - (Paths.SubtermStepInjectionTerm, (Core.fieldTerm (Core.injectionField v0)))] - Core.TermUnit -> [] - Core.TermVariable _ -> [] - Core.TermWrap v0 -> [ - (Paths.SubtermStepWrappedTerm, (Core.wrappedTermBody v0))] - --- | Find the children of a given type expression -subtypes :: Core.Type -> [Core.Type] -subtypes x = - case x of - Core.TypeAnnotated v0 -> [ - Core.annotatedTypeBody v0] - Core.TypeApplication v0 -> [ - Core.applicationTypeFunction v0, - (Core.applicationTypeArgument v0)] - Core.TypeEither v0 -> [ - Core.eitherTypeLeft v0, - (Core.eitherTypeRight v0)] - Core.TypePair v0 -> [ - Core.pairTypeFirst v0, - (Core.pairTypeSecond v0)] - Core.TypeFunction v0 -> [ - Core.functionTypeDomain v0, - (Core.functionTypeCodomain v0)] - Core.TypeForall v0 -> [ - Core.forallTypeBody v0] - Core.TypeList v0 -> [ - v0] - Core.TypeLiteral _ -> [] - Core.TypeMap v0 -> [ - Core.mapTypeKeys v0, - (Core.mapTypeValues v0)] - Core.TypeMaybe v0 -> [ - v0] - Core.TypeRecord v0 -> Lists.map Core.fieldTypeType v0 - Core.TypeSet v0 -> [ - v0] - Core.TypeUnion v0 -> Lists.map Core.fieldTypeType v0 - Core.TypeUnit -> [] - Core.TypeVariable _ -> [] - Core.TypeVoid -> [] - Core.TypeWrap v0 -> [ - v0] - --- | Note: does not distinguish between bound and free variables; use freeVariablesInTerm for that -termDependencyNames :: Bool -> Bool -> Bool -> Core.Term -> S.Set Core.Name -termDependencyNames binds withPrims withNoms term0 = - - let addNames = - \names -> \term -> - let nominal = \name -> Logic.ifElse withNoms (Sets.insert name names) names - prim = \name -> Logic.ifElse withPrims (Sets.insert name names) names - var = \name -> Logic.ifElse binds (Sets.insert name names) names - in case term of - Core.TermFunction v0 -> case v0 of - Core.FunctionPrimitive v1 -> prim v1 - Core.FunctionElimination v1 -> case v1 of - Core.EliminationRecord v2 -> nominal (Core.projectionTypeName v2) - Core.EliminationUnion v2 -> nominal (Core.caseStatementTypeName v2) - Core.EliminationWrap v2 -> nominal v2 - _ -> names - Core.TermRecord v0 -> nominal (Core.recordTypeName v0) - Core.TermUnion v0 -> nominal (Core.injectionTypeName v0) - Core.TermVariable v0 -> var v0 - Core.TermWrap v0 -> nominal (Core.wrappedTermTypeName v0) - _ -> names - in (foldOverTerm Coders.TraversalOrderPre addNames Sets.empty term0) - --- | Generate short names from a list of fully qualified names -toShortNames :: [Core.Name] -> M.Map Core.Name Core.Name -toShortNames original = - - let addName = - \acc -> \name -> - let local = Names.localNameOf name - group = Maybes.fromMaybe Sets.empty (Maps.lookup local acc) - in (Maps.insert local (Sets.insert name group) acc) - groupNamesByLocal = \names -> Lists.foldl addName Maps.empty names - groups = groupNamesByLocal original - renameGroup = - \localNames -> - let local = Pairs.first localNames - names = Pairs.second localNames - rangeFrom = \start -> Lists.cons start (rangeFrom (Math.add start 1)) - rename = - \name -> \i -> (name, (Core.Name (Logic.ifElse (Equality.gt i 1) (Strings.cat2 local (Literals.showInt32 i)) local))) - in (Lists.zipWith rename (Sets.toList names) (rangeFrom 1)) - in (Maps.fromList (Lists.concat (Lists.map renameGroup (Maps.toList groups)))) - --- | Topological sort of connected components, in terms of dependencies between variable/term binding pairs -topologicalSortBindingMap :: M.Map Core.Name Core.Term -> [[(Core.Name, Core.Term)]] -topologicalSortBindingMap bindingMap = - - let bindings = Maps.toList bindingMap - keys = Sets.fromList (Lists.map Pairs.first bindings) - hasTypeAnnotation = - \term -> case term of - Core.TermAnnotated v0 -> hasTypeAnnotation (Core.annotatedTermBody v0) - _ -> False - depsOf = - \nameAndTerm -> - let name = Pairs.first nameAndTerm - term = Pairs.second nameAndTerm - in (name, (Logic.ifElse (hasTypeAnnotation term) [] (Sets.toList (Sets.intersection keys (freeVariablesInTerm term))))) - toPair = - \name -> (name, (Maybes.fromMaybe (Core.TermLiteral (Core.LiteralString "Impossible!")) (Maps.lookup name bindingMap))) - in (Lists.map (Lists.map toPair) (Sorting.topologicalSortComponents (Lists.map depsOf bindings))) - --- | Topological sort of elements based on their dependencies -topologicalSortBindings :: [Core.Binding] -> Either [[Core.Name]] [Core.Name] -topologicalSortBindings els = - - let adjlist = \e -> (Core.bindingName e, (Sets.toList (termDependencyNames False True True (Core.bindingTerm e)))) - in (Sorting.topologicalSort (Lists.map adjlist els)) - -typeDependencyNames :: Bool -> Core.Type -> S.Set Core.Name -typeDependencyNames withSchema typ = - Logic.ifElse withSchema (Sets.union (freeVariablesInType typ) (typeNamesInType typ)) (freeVariablesInType typ) - -typeNamesInType :: Ord t0 => (Core.Type -> S.Set t0) -typeNamesInType typ0 = - - let addNames = \names -> \typ -> names - in (foldOverType Coders.TraversalOrderPre addNames Sets.empty typ0) - --- | Convert a type scheme to a forall type -typeSchemeToFType :: Core.TypeScheme -> Core.Type -typeSchemeToFType ts = - - let vars = Core.typeSchemeVariables ts - body = Core.typeSchemeType ts - in (Lists.foldl (\t -> \v -> Core.TypeForall (Core.ForallType { - Core.forallTypeParameter = v, - Core.forallTypeBody = t})) body (Lists.reverse vars)) - --- | Rename all shadowed variables (both lambda parameters and let-bound variables that shadow lambda parameters) in a term. -unshadowVariables :: Core.Term -> Core.Term -unshadowVariables term0 = - - let freshName = - \base -> \i -> \m -> - let candidate = Core.Name (Strings.cat2 (Core.unName base) (Literals.showInt32 i)) - in (Logic.ifElse (Maps.member candidate m) (freshName base (Math.add i 1) m) candidate) - f = - \recurse -> \m -> \term -> case term of - Core.TermFunction v0 -> case v0 of - Core.FunctionLambda v1 -> - let v = Core.lambdaParameter v1 - domain = Core.lambdaDomain v1 - body = Core.lambdaBody v1 - in (Logic.ifElse (Maps.member v m) ( - let v2 = freshName v 2 m - m2 = Maps.insert v v2 (Maps.insert v2 v2 m) - in (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = v2, - Core.lambdaDomain = domain, - Core.lambdaBody = (f recurse m2 body)})))) (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = v, - Core.lambdaDomain = domain, - Core.lambdaBody = (f recurse (Maps.insert v v m) body)})))) - _ -> recurse m term - Core.TermLet v0 -> - let m2 = - Lists.foldl (\acc -> \b -> - let bname = Core.bindingName b - in (Logic.ifElse (Maps.member bname acc) acc (Maps.insert bname bname acc))) m (Core.letBindings v0) - in (recurse m2 term) - Core.TermVariable v0 -> Core.TermVariable (Maybes.maybe v0 (\renamed -> renamed) (Maps.lookup v0 m)) - _ -> recurse m term - in (rewriteTermWithContext f Maps.empty term0) diff --git a/src/gen-main/haskell/Hydra/Schemas.hs b/src/gen-main/haskell/Hydra/Schemas.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Schemas.hs +++ /dev/null @@ -1,617 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Various functions for dereferencing and decoding schema types. - -module Hydra.Schemas where - -import qualified Hydra.Annotations as Annotations -import qualified Hydra.Coders as Coders -import qualified Hydra.Constants as Constants -import qualified Hydra.Context as Context -import qualified Hydra.Core as Core -import qualified Hydra.Decode.Core as Core_ -import qualified Hydra.Encode.Core as Core__ -import qualified Hydra.Errors as Errors -import qualified Hydra.Graph as Graph -import qualified Hydra.Lexical as Lexical -import qualified Hydra.Lib.Eithers as Eithers -import qualified Hydra.Lib.Equality as Equality -import qualified Hydra.Lib.Lists as Lists -import qualified Hydra.Lib.Literals as Literals -import qualified Hydra.Lib.Logic as Logic -import qualified Hydra.Lib.Maps as Maps -import qualified Hydra.Lib.Math as Math -import qualified Hydra.Lib.Maybes as Maybes -import qualified Hydra.Lib.Pairs as Pairs -import qualified Hydra.Lib.Sets as Sets -import qualified Hydra.Lib.Strings as Strings -import qualified Hydra.Module as Module -import qualified Hydra.Names as Names -import qualified Hydra.Reflect as Reflect -import qualified Hydra.Rewriting as Rewriting -import qualified Hydra.Show.Core as Core___ -import qualified Hydra.Sorting as Sorting -import qualified Hydra.Substitution as Substitution -import qualified Hydra.Typing as Typing -import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | Add names to existing namespaces mapping -addNamesToNamespaces :: (Module.Namespace -> t0) -> S.Set Core.Name -> Module.Namespaces t0 -> Module.Namespaces t0 -addNamesToNamespaces encodeNamespace names ns0 = - - let nss = Sets.fromList (Maybes.cat (Lists.map Names.namespaceOf (Sets.toList names))) - toPair = \ns -> (ns, (encodeNamespace ns)) - in Module.Namespaces { - Module.namespacesFocus = (Module.namespacesFocus ns0), - Module.namespacesMapping = (Maps.union (Module.namespacesMapping ns0) (Maps.fromList (Lists.map toPair (Sets.toList nss))))} - --- | Get dependency namespaces from definitions -definitionDependencyNamespaces :: [Module.Definition] -> S.Set Module.Namespace -definitionDependencyNamespaces defs = - - let defNames = - \def -> case def of - Module.DefinitionType v0 -> Rewriting.typeDependencyNames True (Module.typeDefinitionType v0) - Module.DefinitionTerm v0 -> Rewriting.termDependencyNames True True True (Module.termDefinitionTerm v0) - allNames = Sets.unions (Lists.map defNames defs) - in (Sets.fromList (Maybes.cat (Lists.map Names.namespaceOf (Sets.toList allNames)))) - --- | Find dependency namespaces in all of a set of terms (Either version) -dependencyNamespaces :: Context.Context -> Graph.Graph -> Bool -> Bool -> Bool -> Bool -> [Core.Binding] -> Either (Context.InContext Errors.Error) (S.Set Module.Namespace) -dependencyNamespaces cx graph binds withPrims withNoms withSchema els = - - let depNames = - \el -> - let term = Core.bindingTerm el - deannotatedTerm = Rewriting.deannotateTerm term - dataNames = Rewriting.termDependencyNames binds withPrims withNoms term - schemaNames = - Logic.ifElse withSchema (Maybes.maybe Sets.empty (\ts -> Rewriting.typeDependencyNames True (Core.typeSchemeType ts)) (Core.bindingType el)) Sets.empty - in (Logic.ifElse (isEncodedType deannotatedTerm) (Eithers.map (\typ -> Sets.unions [ - dataNames, - schemaNames, - (Rewriting.typeDependencyNames True typ)]) (Eithers.bimap (\_wc_e -> Context.InContext { - Context.inContextObject = _wc_e, - Context.inContextContext = Context.Context { - Context.contextTrace = (Lists.cons "dependency namespace (type)" (Context.contextTrace cx)), - Context.contextMessages = (Context.contextMessages cx), - Context.contextOther = (Context.contextOther cx)}}) (\_wc_a -> _wc_a) (Eithers.bimap (\_e -> Errors.ErrorOther (Errors.OtherError (Errors.unDecodingError _e))) (\_a -> _a) (Core_.type_ graph term)))) (Logic.ifElse (isEncodedTerm deannotatedTerm) (Eithers.map (\decodedTerm -> Sets.unions [ - dataNames, - schemaNames, - (Rewriting.termDependencyNames binds withPrims withNoms decodedTerm)]) (Eithers.bimap (\_wc_e -> Context.InContext { - Context.inContextObject = _wc_e, - Context.inContextContext = Context.Context { - Context.contextTrace = (Lists.cons "dependency namespace (term)" (Context.contextTrace cx)), - Context.contextMessages = (Context.contextMessages cx), - Context.contextOther = (Context.contextOther cx)}}) (\_wc_a -> _wc_a) (Eithers.bimap (\_e -> Errors.ErrorOther (Errors.OtherError (Errors.unDecodingError _e))) (\_a -> _a) (Core_.term graph term)))) (Right (Sets.unions [ - dataNames, - schemaNames])))) - in (Eithers.map (\namesList -> Sets.fromList (Maybes.cat (Lists.map Names.namespaceOf (Sets.toList (Sets.unions namesList))))) (Eithers.mapList depNames els)) - --- | Dereference a type name to get the actual type (Either version) -dereferenceType :: Context.Context -> Graph.Graph -> Core.Name -> Either (Context.InContext Errors.Error) (Maybe Core.Type) -dereferenceType cx graph name = - - let mel = Lexical.dereferenceElement graph name - in (Maybes.maybe (Right Nothing) (\el -> Eithers.map Maybes.pure (Eithers.bimap (\_wc_e -> Context.InContext { - Context.inContextObject = _wc_e, - Context.inContextContext = cx}) (\_wc_a -> _wc_a) (Eithers.bimap (\_e -> Errors.ErrorOther (Errors.OtherError (Errors.unDecodingError _e))) (\_a -> _a) (Core_.type_ graph (Core.bindingTerm el))))) mel) - --- | Convert an element to a typed term -elementAsTypeApplicationTerm :: Context.Context -> Core.Binding -> Either (Context.InContext Errors.Error) Core.TypeApplicationTerm -elementAsTypeApplicationTerm cx el = - Maybes.maybe (Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError "missing element type")), - Context.inContextContext = cx})) (\ts -> Right (Core.TypeApplicationTerm { - Core.typeApplicationTermBody = (Core.bindingTerm el), - Core.typeApplicationTermType = (Core.typeSchemeType ts)})) (Core.bindingType el) - --- | Get elements with their dependencies -elementsWithDependencies :: Context.Context -> Graph.Graph -> [Core.Binding] -> Either (Context.InContext Errors.Error) [Core.Binding] -elementsWithDependencies cx graph original = - - let depNames = \el -> Sets.toList (Rewriting.termDependencyNames True False False (Core.bindingTerm el)) - allDepNames = Lists.nub (Lists.concat2 (Lists.map Core.bindingName original) (Lists.concat (Lists.map depNames original))) - in (Eithers.mapList (\name -> Lexical.requireElement cx graph name) allDepNames) - --- | Test whether a given System F type is polymorphic (i.e., a forall type) -fTypeIsPolymorphic :: Core.Type -> Bool -fTypeIsPolymorphic typ = - case typ of - Core.TypeAnnotated v0 -> fTypeIsPolymorphic (Core.annotatedTypeBody v0) - Core.TypeForall _ -> True - _ -> False - -fieldMap :: [Core.Field] -> M.Map Core.Name Core.Term -fieldMap fields = - - let toPair = \f -> (Core.fieldName f, (Core.fieldTerm f)) - in (Maps.fromList (Lists.map toPair fields)) - -fieldTypeMap :: [Core.FieldType] -> M.Map Core.Name Core.Type -fieldTypeMap fields = - - let toPair = \f -> (Core.fieldTypeName f, (Core.fieldTypeType f)) - in (Maps.fromList (Lists.map toPair fields)) - --- | Get field types from a record or union type (Either version) -fieldTypes :: Context.Context -> Graph.Graph -> Core.Type -> Either (Context.InContext Errors.Error) (M.Map Core.Name Core.Type) -fieldTypes cx graph t = - - let toMap = \fields -> Maps.fromList (Lists.map (\ft -> (Core.fieldTypeName ft, (Core.fieldTypeType ft))) fields) - in case (Rewriting.deannotateType t) of - Core.TypeForall v0 -> fieldTypes cx graph (Core.forallTypeBody v0) - Core.TypeRecord v0 -> Right (toMap v0) - Core.TypeUnion v0 -> Right (toMap v0) - Core.TypeVariable v0 -> Maybes.maybe (Eithers.bind (Lexical.requireElement cx graph v0) (\el -> Eithers.bind (Eithers.bimap (\_wc_e -> Context.InContext { - Context.inContextObject = _wc_e, - Context.inContextContext = cx}) (\_wc_a -> _wc_a) (Eithers.bimap (\_e -> Errors.ErrorOther (Errors.OtherError (Errors.unDecodingError _e))) (\_a -> _a) (Core_.type_ graph (Core.bindingTerm el)))) (\decodedType -> fieldTypes cx graph decodedType))) (\ts -> fieldTypes cx graph (Core.typeSchemeType ts)) (Maps.lookup v0 (Graph.graphSchemaTypes graph)) - _ -> Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat [ - "expected record or union type but found ", - (Core___.type_ t)]))), - Context.inContextContext = cx}) - --- | Find a field type by name in a list of field types -findFieldType :: Context.Context -> Core.Name -> [Core.FieldType] -> Either (Context.InContext Errors.Error) Core.Type -findFieldType cx fname fields = - - let matchingFields = Lists.filter (\ft -> Equality.equal (Core.unName (Core.fieldTypeName ft)) (Core.unName fname)) fields - in (Logic.ifElse (Lists.null matchingFields) (Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 "No such field: " (Core.unName fname)))), - Context.inContextContext = cx})) (Logic.ifElse (Equality.equal (Lists.length matchingFields) 1) (Right (Core.fieldTypeType (Lists.head matchingFields))) (Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 "Multiple fields named " (Core.unName fname)))), - Context.inContextContext = cx})))) - --- | Generate a fresh type variable name, threading Context -freshName :: Context.Context -> (Core.Name, Context.Context) -freshName cx = - - let count = Annotations.getCount Constants.key_freshTypeVariableCount cx - in (normalTypeVariable count, (Annotations.putCount Constants.key_freshTypeVariableCount (Math.add count 1) cx)) - --- | Generate multiple fresh type variable names, threading Context -freshNames :: Int -> Context.Context -> ([Core.Name], Context.Context) -freshNames n cx = - - let go = - \acc -> \_ -> - let names = Pairs.first acc - cx0 = Pairs.second acc - result = freshName cx0 - name = Pairs.first result - cx1 = Pairs.second result - in (Lists.concat2 names (Lists.pure name), cx1) - in (Lists.foldl go ([], cx) (Lists.replicate n ())) - --- | Fully strip a type of forall quantifiers, normalizing bound variable names for alpha-equivalence comparison -fullyStripAndNormalizeType :: Core.Type -> Core.Type -fullyStripAndNormalizeType typ = - - let go = - \depth -> \subst -> \t -> case (Rewriting.deannotateType t) of - Core.TypeForall v0 -> - let oldVar = Core.forallTypeParameter v0 - newVar = Core.Name (Strings.cat2 "_" (Literals.showInt32 depth)) - in (go (Math.add depth 1) (Maps.insert oldVar newVar subst) (Core.forallTypeBody v0)) - _ -> (subst, t) - result = go 0 Maps.empty typ - subst = Pairs.first result - body = Pairs.second result - in (Rewriting.substituteTypeVariables subst body) - --- | Fully strip a type of forall quantifiers -fullyStripType :: Core.Type -> Core.Type -fullyStripType typ = - case (Rewriting.deannotateType typ) of - Core.TypeForall v0 -> fullyStripType (Core.forallTypeBody v0) - _ -> typ - --- | Convert bindings and a body to a let expression -graphAsLet :: [Core.Binding] -> Core.Term -> Core.Let -graphAsLet bindings body = - Core.Let { - Core.letBindings = bindings, - Core.letBody = body} - --- | Convert bindings and a body to a term, using let-term duality -graphAsTerm :: [Core.Binding] -> Core.Term -> Core.Term -graphAsTerm bindings body = Core.TermLet (graphAsLet bindings body) - --- | Decode a list of type-encoding bindings into a map of named types -graphAsTypes :: Context.Context -> Graph.Graph -> [Core.Binding] -> Either (Context.InContext Errors.DecodingError) (M.Map Core.Name Core.Type) -graphAsTypes cx graph els = - - let toPair = - \el -> Eithers.map (\typ -> (Core.bindingName el, typ)) (Eithers.bimap (\_wc_e -> Context.InContext { - Context.inContextObject = _wc_e, - Context.inContextContext = cx}) (\_wc_a -> _wc_a) (Core_.type_ graph (Core.bindingTerm el))) - in (Eithers.map Maps.fromList (Eithers.mapList toPair els)) - --- | Instantiate a type by replacing all forall-bound type variables with fresh variables, threading Context -instantiateType :: Context.Context -> Core.Type -> (Core.Type, Context.Context) -instantiateType cx typ = - - let result = instantiateTypeScheme cx (typeToTypeScheme typ) - in (Rewriting.typeSchemeToFType (Pairs.first result), (Pairs.second result)) - --- | Instantiate a type scheme with fresh variables, threading Context -instantiateTypeScheme :: Context.Context -> Core.TypeScheme -> (Core.TypeScheme, Context.Context) -instantiateTypeScheme cx scheme = - - let oldVars = Core.typeSchemeVariables scheme - result = freshNames (Lists.length oldVars) cx - newVars = Pairs.first result - cx2 = Pairs.second result - subst = Typing.TypeSubst (Maps.fromList (Lists.zip oldVars (Lists.map (\x -> Core.TypeVariable x) newVars))) - nameSubst = Maps.fromList (Lists.zip oldVars newVars) - renamedConstraints = - Maybes.map (\oldConstraints -> Maps.fromList (Lists.map (\kv -> (Maybes.fromMaybe (Pairs.first kv) (Maps.lookup (Pairs.first kv) nameSubst), (Pairs.second kv))) (Maps.toList oldConstraints))) (Core.typeSchemeConstraints scheme) - in (Core.TypeScheme { - Core.typeSchemeVariables = newVars, - Core.typeSchemeType = (Substitution.substInType subst (Core.typeSchemeType scheme)), - Core.typeSchemeConstraints = renamedConstraints}, cx2) - --- | Determines whether a given term is an encoded term (meta-level term) -isEncodedTerm :: Core.Term -> Bool -isEncodedTerm t = - case (Rewriting.deannotateTerm t) of - Core.TermApplication v0 -> isEncodedTerm (Core.applicationFunction v0) - Core.TermUnion v0 -> Equality.equal "hydra.core.Term" (Core.unName (Core.injectionTypeName v0)) - _ -> False - --- | Determines whether a given term is an encoded type -isEncodedType :: Core.Term -> Bool -isEncodedType t = - case (Rewriting.deannotateTerm t) of - Core.TermApplication v0 -> isEncodedType (Core.applicationFunction v0) - Core.TermUnion v0 -> Equality.equal "hydra.core.Type" (Core.unName (Core.injectionTypeName v0)) - _ -> False - --- | Check if a row type represents an enum (all fields are unit-typed) -isEnumRowType :: [Core.FieldType] -> Bool -isEnumRowType rt = - Lists.foldl Logic.and True (Lists.map (\f -> isUnitType (Rewriting.deannotateType (Core.fieldTypeType f))) rt) - --- | Check if a type is an enum type -isEnumType :: Core.Type -> Bool -isEnumType typ = - case (Rewriting.deannotateType typ) of - Core.TypeUnion v0 -> isEnumRowType v0 - _ -> False - -isNominalType :: Core.Type -> Bool -isNominalType typ = - case (Rewriting.deannotateType typ) of - Core.TypeRecord _ -> True - Core.TypeUnion _ -> True - Core.TypeWrap _ -> True - Core.TypeForall v0 -> isNominalType (Core.forallTypeBody v0) - _ -> False - --- | Check if an element is serializable (no function types in dependencies) (Either version) -isSerializable :: Context.Context -> Graph.Graph -> Core.Binding -> Either (Context.InContext Errors.Error) Bool -isSerializable cx graph el = - - let variants = - \typ -> Lists.map Reflect.typeVariant (Rewriting.foldOverType Coders.TraversalOrderPre (\m -> \t -> Lists.cons t m) [] typ) - in (Eithers.map (\deps -> - let allVariants = Sets.fromList (Lists.concat (Lists.map variants (Maps.elems deps))) - in (Logic.not (Sets.member Variants.TypeVariantFunction allVariants))) (typeDependencies cx graph False Equality.identity (Core.bindingName el))) - --- | Check if a type (by name) is serializable, resolving all type dependencies (Either version) -isSerializableByName :: Context.Context -> Graph.Graph -> Core.Name -> Either (Context.InContext Errors.Error) Bool -isSerializableByName cx graph name = - - let variants = - \typ -> Lists.map Reflect.typeVariant (Rewriting.foldOverType Coders.TraversalOrderPre (\m -> \t -> Lists.cons t m) [] typ) - in (Eithers.map (\deps -> - let allVariants = Sets.fromList (Lists.concat (Lists.map variants (Maps.elems deps))) - in (Logic.not (Sets.member Variants.TypeVariantFunction allVariants))) (typeDependencies cx graph False Equality.identity name)) - --- | Check if a type is serializable (no function types in the type itself) -isSerializableType :: Core.Type -> Bool -isSerializableType typ = - - let allVariants = - Sets.fromList (Lists.map Reflect.typeVariant (Rewriting.foldOverType Coders.TraversalOrderPre (\m -> \t -> Lists.cons t m) [] typ)) - in (Logic.not (Sets.member Variants.TypeVariantFunction allVariants)) - --- | Check whether a type is a type (always true for non-encoded types) -isType :: Core.Type -> Bool -isType t = - case (Rewriting.deannotateType t) of - Core.TypeApplication v0 -> isType (Core.applicationTypeFunction v0) - Core.TypeForall v0 -> isType (Core.forallTypeBody v0) - Core.TypeUnion _ -> False - Core.TypeVariable v0 -> Equality.equal v0 (Core.Name "hydra.core.Type") - _ -> False - --- | Check whether a term is the unit term -isUnitTerm :: Core.Term -> Bool -isUnitTerm x = - case x of - Core.TermUnit -> True - _ -> False - --- | Check whether a type is the unit type -isUnitType :: Core.Type -> Bool -isUnitType x = - case x of - Core.TypeUnit -> True - _ -> False - --- | Check whether a module contains any binary literal values -moduleContainsBinaryLiterals :: Module.Module -> Bool -moduleContainsBinaryLiterals mod = - - let checkTerm = - \found -> \term -> Logic.or found (case term of - Core.TermLiteral v0 -> case v0 of - Core.LiteralBinary _ -> True - _ -> False - _ -> False) - termContainsBinary = \term -> Rewriting.foldOverTerm Coders.TraversalOrderPre checkTerm False term - defTerms = - Maybes.cat (Lists.map (\d -> case d of - Module.DefinitionTerm v0 -> Just (Module.termDefinitionTerm v0) - _ -> Nothing) (Module.moduleDefinitions mod)) - in (Lists.foldl (\acc -> \t -> Logic.or acc (termContainsBinary t)) False defTerms) - --- | Find dependency namespaces in all elements of a module, excluding the module's own namespace (Either version) -moduleDependencyNamespaces :: Context.Context -> Graph.Graph -> Bool -> Bool -> Bool -> Bool -> Module.Module -> Either (Context.InContext Errors.Error) (S.Set Module.Namespace) -moduleDependencyNamespaces cx graph binds withPrims withNoms withSchema mod = - - let allBindings = - Maybes.cat (Lists.map (\d -> case d of - Module.DefinitionType v0 -> Just (Annotations.typeElement (Module.typeDefinitionName v0) (Module.typeDefinitionType v0)) - Module.DefinitionTerm v0 -> Just (Core.Binding { - Core.bindingName = (Module.termDefinitionName v0), - Core.bindingTerm = (Module.termDefinitionTerm v0), - Core.bindingType = (Module.termDefinitionType v0)}) - _ -> Nothing) (Module.moduleDefinitions mod)) - in (Eithers.map (\deps -> Sets.delete (Module.moduleNamespace mod) deps) (dependencyNamespaces cx graph binds withPrims withNoms withSchema allBindings)) - --- | Create namespaces mapping for definitions -namespacesForDefinitions :: (Module.Namespace -> t0) -> Module.Namespace -> [Module.Definition] -> Module.Namespaces t0 -namespacesForDefinitions encodeNamespace focusNs defs = - - let nss = Sets.delete focusNs (definitionDependencyNamespaces defs) - toPair = \ns -> (ns, (encodeNamespace ns)) - in Module.Namespaces { - Module.namespacesFocus = (toPair focusNs), - Module.namespacesMapping = (Maps.fromList (Lists.map toPair (Sets.toList nss)))} - --- | Apply type arguments to a nominal type -nominalApplication :: Core.Name -> [Core.Type] -> Core.Type -nominalApplication tname args = - Lists.foldl (\t -> \a -> Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = t, - Core.applicationTypeArgument = a})) (Core.TypeVariable tname) args - --- | Type variable naming convention follows Haskell: t0, t1, etc. -normalTypeVariable :: Int -> Core.Name -normalTypeVariable i = Core.Name (Strings.cat2 "t" (Literals.showInt32 i)) - --- | Partition a list of definitions into type definitions and term definitions -partitionDefinitions :: [Module.Definition] -> ([Module.TypeDefinition], [Module.TermDefinition]) -partitionDefinitions defs = - - let getType = - \def -> case def of - Module.DefinitionType v0 -> Just v0 - Module.DefinitionTerm _ -> Nothing - getTerm = - \def -> case def of - Module.DefinitionType _ -> Nothing - Module.DefinitionTerm v0 -> Just v0 - in (Maybes.cat (Lists.map getType defs), (Maybes.cat (Lists.map getTerm defs))) - --- | Require a name to resolve to a record type -requireRecordType :: Context.Context -> Graph.Graph -> Core.Name -> Either (Context.InContext Errors.Error) [Core.FieldType] -requireRecordType cx graph name = - - let toRecord = - \t -> case t of - Core.TypeRecord v0 -> Just v0 - _ -> Nothing - in (requireRowType cx "record type" toRecord graph name) - --- | Require a name to resolve to a row type -requireRowType :: Context.Context -> String -> (Core.Type -> Maybe t0) -> Graph.Graph -> Core.Name -> Either (Context.InContext Errors.Error) t0 -requireRowType cx label getter graph name = - - let rawType = - \t -> case t of - Core.TypeAnnotated v0 -> rawType (Core.annotatedTypeBody v0) - Core.TypeForall v0 -> rawType (Core.forallTypeBody v0) - _ -> t - in (Eithers.bind (requireType cx graph name) (\t -> Maybes.maybe (Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat [ - Core.unName name, - " does not resolve to a ", - label, - " type: ", - (Core___.type_ t)]))), - Context.inContextContext = cx})) (\x -> Right x) (getter (rawType t)))) - --- | Look up a schema type and instantiate it, threading Context -requireSchemaType :: Context.Context -> M.Map Core.Name Core.TypeScheme -> Core.Name -> Either (Context.InContext Errors.Error) (Core.TypeScheme, Context.Context) -requireSchemaType cx types tname = - Maybes.maybe (Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat [ - "No such schema type: ", - (Core.unName tname), - ". Available types are: ", - (Strings.intercalate ", " (Lists.map Core.unName (Maps.keys types)))]))), - Context.inContextContext = cx})) (\ts -> Right (instantiateTypeScheme cx (Rewriting.deannotateTypeSchemeRecursive ts))) (Maps.lookup tname types) - --- | Require a type by name -requireType :: Context.Context -> Graph.Graph -> Core.Name -> Either (Context.InContext Errors.Error) Core.Type -requireType cx graph name = - Maybes.maybe (Maybes.maybe (Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat2 "no such type: " (Core.unName name)))), - Context.inContextContext = cx})) (\ts -> Right (Rewriting.typeSchemeToFType ts)) (Maps.lookup name (Graph.graphBoundTypes graph))) (\ts -> Right (Rewriting.typeSchemeToFType ts)) (Maps.lookup name (Graph.graphSchemaTypes graph)) - --- | Require a field type from a union type -requireUnionField :: Context.Context -> Graph.Graph -> Core.Name -> Core.Name -> Either (Context.InContext Errors.Error) Core.Type -requireUnionField cx graph tname fname = - - let withRowType = - \rt -> - let matches = Lists.filter (\ft -> Equality.equal (Core.fieldTypeName ft) fname) rt - in (Logic.ifElse (Lists.null matches) (Left (Context.InContext { - Context.inContextObject = (Errors.ErrorOther (Errors.OtherError (Strings.cat [ - "no field \"", - (Core.unName fname), - "\" in union type \"", - (Core.unName tname)]))), - Context.inContextContext = cx})) (Right (Core.fieldTypeType (Lists.head matches)))) - in (Eithers.bind (requireUnionType cx graph tname) withRowType) - --- | Require a name to resolve to a union type -requireUnionType :: Context.Context -> Graph.Graph -> Core.Name -> Either (Context.InContext Errors.Error) [Core.FieldType] -requireUnionType cx graph name = - - let toUnion = - \t -> case t of - Core.TypeUnion v0 -> Just v0 - _ -> Nothing - in (requireRowType cx "union" toUnion graph name) - --- | Resolve a type, dereferencing type variables -resolveType :: Graph.Graph -> Core.Type -> Maybe Core.Type -resolveType graph typ = - case (Rewriting.deannotateType typ) of - Core.TypeVariable v0 -> Maybes.maybe (Maybes.map (\ts -> Rewriting.typeSchemeToFType ts) (Maps.lookup v0 (Graph.graphBoundTypes graph))) (\ts -> Just (Rewriting.typeSchemeToFType ts)) (Maps.lookup v0 (Graph.graphSchemaTypes graph)) - _ -> Just typ - --- | Convert a schema graph to a typing environment (Either version) -schemaGraphToTypingEnvironment :: Context.Context -> Graph.Graph -> Either (Context.InContext Errors.Error) (M.Map Core.Name Core.TypeScheme) -schemaGraphToTypingEnvironment cx g = - - let toTypeScheme = - \vars -> \typ -> case (Rewriting.deannotateType typ) of - Core.TypeForall v0 -> toTypeScheme (Lists.cons (Core.forallTypeParameter v0) vars) (Core.forallTypeBody v0) - _ -> Core.TypeScheme { - Core.typeSchemeVariables = (Lists.reverse vars), - Core.typeSchemeType = typ, - Core.typeSchemeConstraints = Nothing} - decodeType = - \term -> Eithers.bimap (\_wc_e -> Context.InContext { - Context.inContextObject = _wc_e, - Context.inContextContext = cx}) (\_wc_a -> _wc_a) (Eithers.bimap (\_e -> Errors.ErrorOther (Errors.OtherError (Errors.unDecodingError _e))) (\_a -> _a) (Core_.type_ g term)) - decodeTypeScheme = - \term -> Eithers.bimap (\_wc_e -> Context.InContext { - Context.inContextObject = _wc_e, - Context.inContextContext = cx}) (\_wc_a -> _wc_a) (Eithers.bimap (\_e -> Errors.ErrorOther (Errors.OtherError (Errors.unDecodingError _e))) (\_a -> _a) (Core_.typeScheme g term)) - toPair = - \el -> - let forTerm = - \term -> case term of - Core.TermRecord v0 -> Logic.ifElse (Equality.equal (Core.recordTypeName v0) (Core.Name "hydra.core.TypeScheme")) (Eithers.map Maybes.pure (decodeTypeScheme (Core.bindingTerm el))) (Right Nothing) - Core.TermUnion v0 -> Logic.ifElse (Equality.equal (Core.injectionTypeName v0) (Core.Name "hydra.core.Type")) (Eithers.map (\decoded -> Just (toTypeScheme [] decoded)) (decodeType (Core.bindingTerm el))) (Right Nothing) - _ -> Right Nothing - in (Eithers.bind (Maybes.maybe (Eithers.map (\typ -> Just (Rewriting.fTypeToTypeScheme typ)) (decodeType (Core.bindingTerm el))) (\ts -> Logic.ifElse (Equality.equal ts (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeVariable (Core.Name "hydra.core.TypeScheme")), - Core.typeSchemeConstraints = Nothing})) (Eithers.map Maybes.pure (decodeTypeScheme (Core.bindingTerm el))) (Logic.ifElse (Equality.equal ts (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeVariable (Core.Name "hydra.core.Type")), - Core.typeSchemeConstraints = Nothing})) (Eithers.map (\decoded -> Just (toTypeScheme [] decoded)) (decodeType (Core.bindingTerm el))) (forTerm (Rewriting.deannotateTerm (Core.bindingTerm el))))) (Core.bindingType el)) (\mts -> Right (Maybes.map (\ts -> (Core.bindingName el, ts)) mts))) - in (Eithers.map (\mpairs -> Maps.fromList (Maybes.cat mpairs)) (Eithers.mapList toPair (Lexical.graphToBindings g))) - --- | Extract the bindings from a let term, or return an empty list for other terms -termAsBindings :: Core.Term -> [Core.Binding] -termAsBindings term = - case (Rewriting.deannotateTerm term) of - Core.TermLet v0 -> Core.letBindings v0 - _ -> [] - --- | Topologically sort type definitions by dependencies -topologicalSortTypeDefinitions :: [Module.TypeDefinition] -> [[Module.TypeDefinition]] -topologicalSortTypeDefinitions defs = - - let toPair = - \def -> (Module.typeDefinitionName def, (Sets.toList (Rewriting.typeDependencyNames False (Module.typeDefinitionType def)))) - nameToDef = Maps.fromList (Lists.map (\d -> (Module.typeDefinitionName d, d)) defs) - sorted = Sorting.topologicalSortComponents (Lists.map toPair defs) - in (Lists.map (\names -> Maybes.cat (Lists.map (\n -> Maps.lookup n nameToDef) names)) sorted) - --- | Get all type dependencies for a given type name (Either version) -typeDependencies :: Context.Context -> Graph.Graph -> Bool -> (Core.Type -> Core.Type) -> Core.Name -> Either (Context.InContext Errors.Error) (M.Map Core.Name Core.Type) -typeDependencies cx graph withSchema transform name = - - let requireType = - \name -> - let cx1 = - Context.Context { - Context.contextTrace = (Lists.cons (Strings.cat2 "type dependencies of " (Core.unName name)) (Context.contextTrace cx)), - Context.contextMessages = (Context.contextMessages cx), - Context.contextOther = (Context.contextOther cx)} - in (Eithers.bind (Lexical.requireElement cx1 graph name) (\el -> Eithers.bimap (\_wc_e -> Context.InContext { - Context.inContextObject = _wc_e, - Context.inContextContext = cx1}) (\_wc_a -> _wc_a) (Eithers.bimap (\_e -> Errors.ErrorOther (Errors.OtherError (Errors.unDecodingError _e))) (\_a -> _a) (Core_.type_ graph (Core.bindingTerm el))))) - toPair = \name -> Eithers.map (\typ -> (name, (transform typ))) (requireType name) - deps = - \seeds -> \names -> Logic.ifElse (Sets.null seeds) (Right names) (Eithers.bind (Eithers.mapList toPair (Sets.toList seeds)) (\pairs -> - let newNames = Maps.union names (Maps.fromList pairs) - refs = - Lists.foldl Sets.union Sets.empty (Lists.map (\pair -> Rewriting.typeDependencyNames withSchema (Pairs.second pair)) pairs) - visited = Sets.fromList (Maps.keys names) - newSeeds = Sets.difference refs visited - in (deps newSeeds newNames))) - in (deps (Sets.singleton name) Maps.empty) - --- | Convert a (System F -style) type to a type scheme -typeToTypeScheme :: Core.Type -> Core.TypeScheme -typeToTypeScheme t0 = - - let helper = - \vars -> \t -> case (Rewriting.deannotateType t) of - Core.TypeForall v0 -> helper (Lists.cons (Core.forallTypeParameter v0) vars) (Core.forallTypeBody v0) - _ -> Core.TypeScheme { - Core.typeSchemeVariables = (Lists.reverse vars), - Core.typeSchemeType = t, - Core.typeSchemeConstraints = Nothing} - in (helper [] t0) - --- | Encode a map of named types to a list of elements -typesToElements :: M.Map Core.Name Core.Type -> [Core.Binding] -typesToElements typeMap = - - let toElement = - \pair -> - let name = Pairs.first pair - in Core.Binding { - Core.bindingName = name, - Core.bindingTerm = (Core__.type_ (Pairs.second pair)), - Core.bindingType = Nothing} - in (Lists.map toElement (Maps.toList typeMap)) - --- | Execute a computation in the context of a lambda body, extending the type context with the lambda parameter -withLambdaContext :: (t0 -> Graph.Graph) -> (Graph.Graph -> t0 -> t1) -> t0 -> Core.Lambda -> (t1 -> t2) -> t2 -withLambdaContext getContext setContext env lam body = - - let newContext = Rewriting.extendGraphForLambda (getContext env) lam - in (body (setContext newContext env)) - --- | Execute a computation in the context of a let body, extending the type context with the let bindings -withLetContext :: (t0 -> Graph.Graph) -> (Graph.Graph -> t0 -> t1) -> (Graph.Graph -> Core.Binding -> Maybe Core.Term) -> t0 -> Core.Let -> (t1 -> t2) -> t2 -withLetContext getContext setContext forBinding env letrec body = - - let newContext = Rewriting.extendGraphForLet forBinding (getContext env) letrec - in (body (setContext newContext env)) - --- | Execute a computation in the context of a type lambda body, extending the type context with the type parameter -withTypeLambdaContext :: (t0 -> Graph.Graph) -> (Graph.Graph -> t0 -> t1) -> t0 -> Core.TypeLambda -> (t1 -> t2) -> t2 -withTypeLambdaContext getContext setContext env tlam body = - - let newContext = Rewriting.extendGraphForTypeLambda (getContext env) tlam - in (body (setContext newContext env)) diff --git a/src/gen-main/haskell/Hydra/Serialization.hs b/src/gen-main/haskell/Hydra/Serialization.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Serialization.hs +++ /dev/null @@ -1,537 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Utilities for constructing generic program code ASTs, used for the serialization phase of source code generation. - -module Hydra.Serialization where - -import qualified Hydra.Ast as Ast -import qualified Hydra.Lib.Equality as Equality -import qualified Hydra.Lib.Lists as Lists -import qualified Hydra.Lib.Literals as Literals -import qualified Hydra.Lib.Logic as Logic -import qualified Hydra.Lib.Math as Math -import qualified Hydra.Lib.Maybes as Maybes -import qualified Hydra.Lib.Strings as Strings -import qualified Hydra.Util as Util -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -angleBraces :: Ast.Brackets -angleBraces = - Ast.Brackets { - Ast.bracketsOpen = (Ast.Symbol "<"), - Ast.bracketsClose = (Ast.Symbol ">")} - -angleBracesList :: Ast.BlockStyle -> [Ast.Expr] -> Ast.Expr -angleBracesList style els = Logic.ifElse (Lists.null els) (cst "<>") (brackets angleBraces style (commaSep style els)) - --- | Produce a bracketed list which separates elements by spaces or newlines depending on the estimated width of the expression. -bracesListAdaptive :: [Ast.Expr] -> Ast.Expr -bracesListAdaptive els = - - let inlineList = curlyBracesList Nothing inlineStyle els - in (Logic.ifElse (Equality.gt (expressionLength inlineList) 70) (curlyBracesList Nothing halfBlockStyle els) inlineList) - -bracketList :: Ast.BlockStyle -> [Ast.Expr] -> Ast.Expr -bracketList style els = Logic.ifElse (Lists.null els) (cst "[]") (brackets squareBrackets style (commaSep style els)) - --- | Produce a bracketed list which separates elements by spaces or newlines depending on the estimated width of the expression. -bracketListAdaptive :: [Ast.Expr] -> Ast.Expr -bracketListAdaptive els = - - let inlineList = bracketList inlineStyle els - in (Logic.ifElse (Equality.gt (expressionLength inlineList) 70) (bracketList halfBlockStyle els) inlineList) - -brackets :: Ast.Brackets -> Ast.BlockStyle -> Ast.Expr -> Ast.Expr -brackets br style e = - Ast.ExprBrackets (Ast.BracketExpr { - Ast.bracketExprBrackets = br, - Ast.bracketExprEnclosed = e, - Ast.bracketExprStyle = style}) - -commaSep :: Ast.BlockStyle -> [Ast.Expr] -> Ast.Expr -commaSep = symbolSep "," - -cst :: String -> Ast.Expr -cst s = Ast.ExprConst (sym s) - -curlyBlock :: Ast.BlockStyle -> Ast.Expr -> Ast.Expr -curlyBlock style e = curlyBracesList Nothing style [ - e] - -curlyBraces :: Ast.Brackets -curlyBraces = - Ast.Brackets { - Ast.bracketsOpen = (Ast.Symbol "{"), - Ast.bracketsClose = (Ast.Symbol "}")} - -curlyBracesList :: Maybe String -> Ast.BlockStyle -> [Ast.Expr] -> Ast.Expr -curlyBracesList msymb style els = - Logic.ifElse (Lists.null els) (cst "{}") (brackets curlyBraces style (symbolSep (Maybes.fromMaybe "," msymb) style els)) - -customIndent :: String -> String -> String -customIndent idt s = Strings.cat (Lists.intersperse "\n" (Lists.map (\line -> Strings.cat2 idt line) (Strings.lines s))) - -customIndentBlock :: String -> [Ast.Expr] -> Ast.Expr -customIndentBlock idt els = - - let idtOp = - Ast.Op { - Ast.opSymbol = (sym ""), - Ast.opPadding = Ast.Padding { - Ast.paddingLeft = Ast.WsSpace, - Ast.paddingRight = (Ast.WsBreakAndIndent idt)}, - Ast.opPrecedence = (Ast.Precedence 0), - Ast.opAssociativity = Ast.AssociativityNone} - in (Maybes.maybe (cst "") (\head -> Logic.ifElse (Equality.equal (Lists.length els) 1) head (ifx idtOp head (newlineSep (Lists.drop 1 els)))) (Lists.safeHead els)) - -dotSep :: [Ast.Expr] -> Ast.Expr -dotSep = - sep (Ast.Op { - Ast.opSymbol = (sym "."), - Ast.opPadding = Ast.Padding { - Ast.paddingLeft = Ast.WsNone, - Ast.paddingRight = Ast.WsNone}, - Ast.opPrecedence = (Ast.Precedence 0), - Ast.opAssociativity = Ast.AssociativityNone}) - -doubleNewlineSep :: [Ast.Expr] -> Ast.Expr -doubleNewlineSep = - sep (Ast.Op { - Ast.opSymbol = (sym ""), - Ast.opPadding = Ast.Padding { - Ast.paddingLeft = Ast.WsBreak, - Ast.paddingRight = Ast.WsBreak}, - Ast.opPrecedence = (Ast.Precedence 0), - Ast.opAssociativity = Ast.AssociativityNone}) - -doubleSpace :: String -doubleSpace = " " - --- | Find the approximate length (number of characters, including spaces and newlines) of an expression without actually printing it. -expressionLength :: Ast.Expr -> Int -expressionLength e = - - let symbolLength = \s -> Strings.length (Ast.unSymbol s) - wsLength = - \ws -> case ws of - Ast.WsNone -> 0 - Ast.WsSpace -> 1 - Ast.WsBreak -> 10000 - Ast.WsBreakAndIndent _ -> 10000 - Ast.WsDoubleBreak -> 10000 - blockStyleLength = - \style -> - let mindentLen = Maybes.maybe 0 Strings.length (Ast.blockStyleIndent style) - nlBeforeLen = Logic.ifElse (Ast.blockStyleNewlineBeforeContent style) 1 0 - nlAfterLen = Logic.ifElse (Ast.blockStyleNewlineAfterContent style) 1 0 - in (Math.add mindentLen (Math.add nlBeforeLen nlAfterLen)) - bracketsLength = - \brackets -> Math.add (symbolLength (Ast.bracketsOpen brackets)) (symbolLength (Ast.bracketsClose brackets)) - bracketExprLength = - \be -> Math.add (bracketsLength (Ast.bracketExprBrackets be)) (Math.add (expressionLength (Ast.bracketExprEnclosed be)) (blockStyleLength (Ast.bracketExprStyle be))) - indentedExpressionLength = - \ie -> - let baseLen = expressionLength (Ast.indentedExpressionExpr ie) - indentLen = - case (Ast.indentedExpressionStyle ie) of - Ast.IndentStyleAllLines v0 -> Strings.length v0 - Ast.IndentStyleSubsequentLines v0 -> Strings.length v0 - in (Math.add baseLen indentLen) - opLength = - \op -> - let symLen = symbolLength (Ast.opSymbol op) - padding = Ast.opPadding op - leftLen = wsLength (Ast.paddingLeft padding) - rightLen = wsLength (Ast.paddingRight padding) - in (Math.add symLen (Math.add leftLen rightLen)) - opExprLength = - \oe -> - let opLen = opLength (Ast.opExprOp oe) - leftLen = expressionLength (Ast.opExprLhs oe) - rightLen = expressionLength (Ast.opExprRhs oe) - in (Math.add opLen (Math.add leftLen rightLen)) - seqExprLength = - \se -> - let sopLen = opLength (Ast.seqExprOp se) - elementLens = Lists.map expressionLength (Ast.seqExprElements se) - totalElLen = Lists.foldl Math.add 0 elementLens - numSeps = Math.sub (Lists.length (Ast.seqExprElements se)) 1 - in (Math.add totalElLen (Math.mul sopLen (Logic.ifElse (Equality.gt numSeps 0) numSeps 0))) - in case e of - Ast.ExprConst v0 -> symbolLength v0 - Ast.ExprIndent v0 -> indentedExpressionLength v0 - Ast.ExprOp v0 -> opExprLength v0 - Ast.ExprBrackets v0 -> bracketExprLength v0 - Ast.ExprSeq v0 -> seqExprLength v0 - -fullBlockStyle :: Ast.BlockStyle -fullBlockStyle = - Ast.BlockStyle { - Ast.blockStyleIndent = (Just doubleSpace), - Ast.blockStyleNewlineBeforeContent = True, - Ast.blockStyleNewlineAfterContent = True} - -halfBlockStyle :: Ast.BlockStyle -halfBlockStyle = - Ast.BlockStyle { - Ast.blockStyleIndent = (Just doubleSpace), - Ast.blockStyleNewlineBeforeContent = True, - Ast.blockStyleNewlineAfterContent = False} - -ifx :: Ast.Op -> Ast.Expr -> Ast.Expr -> Ast.Expr -ifx op lhs rhs = - Ast.ExprOp (Ast.OpExpr { - Ast.opExprOp = op, - Ast.opExprLhs = lhs, - Ast.opExprRhs = rhs}) - -indent :: String -> String -indent = customIndent doubleSpace - -indentBlock :: [Ast.Expr] -> Ast.Expr -indentBlock = customIndentBlock doubleSpace - -indentSubsequentLines :: String -> Ast.Expr -> Ast.Expr -indentSubsequentLines idt e = - Ast.ExprIndent (Ast.IndentedExpression { - Ast.indentedExpressionStyle = (Ast.IndentStyleSubsequentLines idt), - Ast.indentedExpressionExpr = e}) - -infixWs :: String -> Ast.Expr -> Ast.Expr -> Ast.Expr -infixWs op l r = - spaceSep [ - l, - (cst op), - r] - -infixWsList :: String -> [Ast.Expr] -> Ast.Expr -infixWsList op opers = - - let opExpr = cst op - foldFun = \e -> \r -> Logic.ifElse (Lists.null e) [ - r] (Lists.cons r (Lists.cons opExpr e)) - in (spaceSep (Lists.foldl foldFun [] (Lists.reverse opers))) - -inlineStyle :: Ast.BlockStyle -inlineStyle = - Ast.BlockStyle { - Ast.blockStyleIndent = Nothing, - Ast.blockStyleNewlineBeforeContent = False, - Ast.blockStyleNewlineAfterContent = False} - -newlineSep :: [Ast.Expr] -> Ast.Expr -newlineSep = - sep (Ast.Op { - Ast.opSymbol = (sym ""), - Ast.opPadding = Ast.Padding { - Ast.paddingLeft = Ast.WsNone, - Ast.paddingRight = Ast.WsBreak}, - Ast.opPrecedence = (Ast.Precedence 0), - Ast.opAssociativity = Ast.AssociativityNone}) - -noPadding :: Ast.Padding -noPadding = - Ast.Padding { - Ast.paddingLeft = Ast.WsNone, - Ast.paddingRight = Ast.WsNone} - -noSep :: [Ast.Expr] -> Ast.Expr -noSep = - sep (Ast.Op { - Ast.opSymbol = (sym ""), - Ast.opPadding = Ast.Padding { - Ast.paddingLeft = Ast.WsNone, - Ast.paddingRight = Ast.WsNone}, - Ast.opPrecedence = (Ast.Precedence 0), - Ast.opAssociativity = Ast.AssociativityNone}) - -num :: Int -> Ast.Expr -num i = cst (Literals.showInt32 i) - -op :: String -> Int -> Ast.Associativity -> Ast.Op -op s p assoc = - Ast.Op { - Ast.opSymbol = (sym s), - Ast.opPadding = Ast.Padding { - Ast.paddingLeft = Ast.WsSpace, - Ast.paddingRight = Ast.WsSpace}, - Ast.opPrecedence = (Ast.Precedence p), - Ast.opAssociativity = assoc} - -orOp :: Bool -> Ast.Op -orOp newlines = - Ast.Op { - Ast.opSymbol = (sym "|"), - Ast.opPadding = Ast.Padding { - Ast.paddingLeft = Ast.WsSpace, - Ast.paddingRight = (Logic.ifElse newlines Ast.WsBreak Ast.WsSpace)}, - Ast.opPrecedence = (Ast.Precedence 0), - Ast.opAssociativity = Ast.AssociativityNone} - -orSep :: Ast.BlockStyle -> [Ast.Expr] -> Ast.Expr -orSep style l = - - let newlines = Ast.blockStyleNewlineBeforeContent style - in (Maybes.maybe (cst "") (\h -> Lists.foldl (\acc -> \el -> ifx (orOp newlines) acc el) h (Lists.drop 1 l)) (Lists.safeHead l)) - -parenList :: Bool -> [Ast.Expr] -> Ast.Expr -parenList newlines els = - - let style = Logic.ifElse (Logic.and newlines (Equality.gt (Lists.length els) 1)) halfBlockStyle inlineStyle - in (Logic.ifElse (Lists.null els) (cst "()") (brackets parentheses style (commaSep style els))) - -parens :: Ast.Expr -> Ast.Expr -parens = brackets parentheses inlineStyle - -parentheses :: Ast.Brackets -parentheses = - Ast.Brackets { - Ast.bracketsOpen = (Ast.Symbol "("), - Ast.bracketsClose = (Ast.Symbol ")")} - -parenthesize :: Ast.Expr -> Ast.Expr -parenthesize exp = - - let assocLeft = - \a -> case a of - Ast.AssociativityRight -> False - _ -> True - assocRight = - \a -> case a of - Ast.AssociativityLeft -> False - _ -> True - in case exp of - Ast.ExprBrackets v0 -> Ast.ExprBrackets (Ast.BracketExpr { - Ast.bracketExprBrackets = (Ast.bracketExprBrackets v0), - Ast.bracketExprEnclosed = (parenthesize (Ast.bracketExprEnclosed v0)), - Ast.bracketExprStyle = (Ast.bracketExprStyle v0)}) - Ast.ExprConst _ -> exp - Ast.ExprIndent v0 -> Ast.ExprIndent (Ast.IndentedExpression { - Ast.indentedExpressionStyle = (Ast.indentedExpressionStyle v0), - Ast.indentedExpressionExpr = (parenthesize (Ast.indentedExpressionExpr v0))}) - Ast.ExprSeq v0 -> Ast.ExprSeq (Ast.SeqExpr { - Ast.seqExprOp = (Ast.seqExprOp v0), - Ast.seqExprElements = (Lists.map parenthesize (Ast.seqExprElements v0))}) - Ast.ExprOp v0 -> - let op = Ast.opExprOp v0 - prec = Ast.unPrecedence (Ast.opPrecedence op) - assoc = Ast.opAssociativity op - lhs = Ast.opExprLhs v0 - rhs = Ast.opExprRhs v0 - lhs_ = parenthesize lhs - rhs_ = parenthesize rhs - lhs2 = - case lhs_ of - Ast.ExprOp v1 -> - let lop = Ast.opExprOp v1 - lprec = Ast.unPrecedence (Ast.opPrecedence lop) - lassoc = Ast.opAssociativity lop - comparison = Equality.compare prec lprec - in case comparison of - Util.ComparisonLessThan -> lhs_ - Util.ComparisonGreaterThan -> parens lhs_ - Util.ComparisonEqualTo -> Logic.ifElse (Logic.and (assocLeft assoc) (assocLeft lassoc)) lhs_ (parens lhs_) - _ -> lhs_ - rhs2 = - case rhs_ of - Ast.ExprOp v1 -> - let rop = Ast.opExprOp v1 - rprec = Ast.unPrecedence (Ast.opPrecedence rop) - rassoc = Ast.opAssociativity rop - comparison = Equality.compare prec rprec - in case comparison of - Util.ComparisonLessThan -> rhs_ - Util.ComparisonGreaterThan -> parens rhs_ - Util.ComparisonEqualTo -> Logic.ifElse (Logic.and (assocRight assoc) (assocRight rassoc)) rhs_ (parens rhs_) - _ -> rhs_ - in (Ast.ExprOp (Ast.OpExpr { - Ast.opExprOp = op, - Ast.opExprLhs = lhs2, - Ast.opExprRhs = rhs2})) - -prefix :: String -> Ast.Expr -> Ast.Expr -prefix p expr = - - let preOp = - Ast.Op { - Ast.opSymbol = (sym p), - Ast.opPadding = Ast.Padding { - Ast.paddingLeft = Ast.WsNone, - Ast.paddingRight = Ast.WsNone}, - Ast.opPrecedence = (Ast.Precedence 0), - Ast.opAssociativity = Ast.AssociativityNone} - in (ifx preOp (cst "") expr) - -printExpr :: Ast.Expr -> String -printExpr e = - - let pad = - \ws -> case ws of - Ast.WsNone -> "" - Ast.WsSpace -> " " - Ast.WsBreak -> "\n" - Ast.WsBreakAndIndent _ -> "\n" - Ast.WsDoubleBreak -> "\n\n" - idt = - \ws -> \s -> case ws of - Ast.WsBreakAndIndent v0 -> customIndent v0 s - _ -> s - in case e of - Ast.ExprConst v0 -> Ast.unSymbol v0 - Ast.ExprIndent v0 -> - let style = Ast.indentedExpressionStyle v0 - expr = Ast.indentedExpressionExpr v0 - lns = Strings.lines (printExpr expr) - ilns = - case style of - Ast.IndentStyleAllLines v1 -> Lists.map (\line -> Strings.cat2 v1 line) lns - Ast.IndentStyleSubsequentLines v1 -> Logic.ifElse (Equality.equal (Lists.length lns) 1) lns (Lists.cons (Lists.head lns) (Lists.map (\line -> Strings.cat2 v1 line) (Lists.tail lns))) - in (Strings.intercalate "\n" ilns) - Ast.ExprSeq v0 -> - let sop = Ast.seqExprOp v0 - ssym = Ast.unSymbol (Ast.opSymbol sop) - spadding = Ast.opPadding sop - spadl = Ast.paddingLeft spadding - spadr = Ast.paddingRight spadding - selements = Ast.seqExprElements v0 - separator = Strings.cat2 (Strings.cat2 (pad spadl) ssym) (pad spadr) - printedElements = Lists.map (\el -> idt spadr (printExpr el)) selements - in (Strings.intercalate separator printedElements) - Ast.ExprOp v0 -> - let op = Ast.opExprOp v0 - sym = Ast.unSymbol (Ast.opSymbol op) - padding = Ast.opPadding op - padl = Ast.paddingLeft padding - padr = Ast.paddingRight padding - l = Ast.opExprLhs v0 - r = Ast.opExprRhs v0 - lhs = idt padl (printExpr l) - rhs = idt padr (printExpr r) - in (Strings.cat2 (Strings.cat2 (Strings.cat2 (Strings.cat2 lhs (pad padl)) sym) (pad padr)) rhs) - Ast.ExprBrackets v0 -> - let brs = Ast.bracketExprBrackets v0 - l = Ast.unSymbol (Ast.bracketsOpen brs) - r = Ast.unSymbol (Ast.bracketsClose brs) - e = Ast.bracketExprEnclosed v0 - style = Ast.bracketExprStyle v0 - body = printExpr e - doIndent = Ast.blockStyleIndent style - nlBefore = Ast.blockStyleNewlineBeforeContent style - nlAfter = Ast.blockStyleNewlineAfterContent style - ibody = Maybes.maybe body (\idt -> customIndent idt body) doIndent - pre = Logic.ifElse nlBefore "\n" "" - suf = Logic.ifElse nlAfter "\n" "" - in (Strings.cat2 (Strings.cat2 (Strings.cat2 (Strings.cat2 l pre) ibody) suf) r) - -semicolonSep :: [Ast.Expr] -> Ast.Expr -semicolonSep = symbolSep ";" inlineStyle - -sep :: Ast.Op -> [Ast.Expr] -> Ast.Expr -sep op els = - Maybes.maybe (cst "") (\h -> Lists.foldl (\acc -> \el -> ifx op acc el) h (Lists.drop 1 els)) (Lists.safeHead els) - -spaceSep :: [Ast.Expr] -> Ast.Expr -spaceSep = - sep (Ast.Op { - Ast.opSymbol = (sym ""), - Ast.opPadding = Ast.Padding { - Ast.paddingLeft = Ast.WsSpace, - Ast.paddingRight = Ast.WsNone}, - Ast.opPrecedence = (Ast.Precedence 0), - Ast.opAssociativity = Ast.AssociativityNone}) - -squareBrackets :: Ast.Brackets -squareBrackets = - Ast.Brackets { - Ast.bracketsOpen = (Ast.Symbol "["), - Ast.bracketsClose = (Ast.Symbol "]")} - --- | Like sep, but produces a SeqExpr instead of an OpExpr chain. SeqExpr is treated as structural layout and is not subject to parenthesization. -structuralSep :: Ast.Op -> [Ast.Expr] -> Ast.Expr -structuralSep op els = - Logic.ifElse (Lists.null els) (cst "") (Logic.ifElse (Equality.equal (Lists.length els) 1) (Lists.head els) (Ast.ExprSeq (Ast.SeqExpr { - Ast.seqExprOp = op, - Ast.seqExprElements = els}))) - --- | Like spaceSep, but produces a SeqExpr. Use for structural layout that should not trigger parenthesization of children. -structuralSpaceSep :: [Ast.Expr] -> Ast.Expr -structuralSpaceSep = - structuralSep (Ast.Op { - Ast.opSymbol = (sym ""), - Ast.opPadding = Ast.Padding { - Ast.paddingLeft = Ast.WsSpace, - Ast.paddingRight = Ast.WsNone}, - Ast.opPrecedence = (Ast.Precedence 0), - Ast.opAssociativity = Ast.AssociativityNone}) - --- | Append a suffix string to an expression -suffix :: String -> Ast.Expr -> Ast.Expr -suffix s expr = - - let sufOp = - Ast.Op { - Ast.opSymbol = (sym s), - Ast.opPadding = Ast.Padding { - Ast.paddingLeft = Ast.WsNone, - Ast.paddingRight = Ast.WsNone}, - Ast.opPrecedence = (Ast.Precedence 0), - Ast.opAssociativity = Ast.AssociativityNone} - in (ifx sufOp expr (cst "")) - -sym :: String -> Ast.Symbol -sym s = Ast.Symbol s - -symbolSep :: String -> Ast.BlockStyle -> [Ast.Expr] -> Ast.Expr -symbolSep symb style l = - - let breakCount = - Lists.length (Lists.filter (\x_ -> x_) [ - Ast.blockStyleNewlineBeforeContent style, - (Ast.blockStyleNewlineAfterContent style)]) - break = - Logic.ifElse (Equality.equal breakCount 0) Ast.WsSpace (Logic.ifElse (Equality.equal breakCount 1) Ast.WsBreak Ast.WsDoubleBreak) - commaOp = - Ast.Op { - Ast.opSymbol = (sym symb), - Ast.opPadding = Ast.Padding { - Ast.paddingLeft = Ast.WsNone, - Ast.paddingRight = break}, - Ast.opPrecedence = (Ast.Precedence 0), - Ast.opAssociativity = Ast.AssociativityNone} - in (Maybes.maybe (cst "") (\h -> Lists.foldl (\acc -> \el -> ifx commaOp acc el) h (Lists.drop 1 l)) (Lists.safeHead l)) - -tabIndent :: Ast.Expr -> Ast.Expr -tabIndent e = - Ast.ExprIndent (Ast.IndentedExpression { - Ast.indentedExpressionStyle = (Ast.IndentStyleAllLines " "), - Ast.indentedExpressionExpr = e}) - -tabIndentDoubleSpace :: [Ast.Expr] -> Ast.Expr -tabIndentDoubleSpace exprs = tabIndent (doubleNewlineSep exprs) - -tabIndentSingleSpace :: [Ast.Expr] -> Ast.Expr -tabIndentSingleSpace exprs = tabIndent (newlineSep exprs) - -unsupportedType :: String -> Ast.Expr -unsupportedType label = cst (Strings.cat2 (Strings.cat2 "[" label) "]") - -unsupportedVariant :: String -> String -> Ast.Expr -unsupportedVariant label obj = - cst (Strings.cat2 (Strings.cat2 (Strings.cat2 (Strings.cat2 "[unsupported " label) ": ") (Literals.showString obj)) "]") - -withComma :: Ast.Expr -> Ast.Expr -withComma e = - noSep [ - e, - (cst ",")] - -withSemi :: Ast.Expr -> Ast.Expr -withSemi e = - noSep [ - e, - (cst ";")] diff --git a/src/gen-main/haskell/Hydra/Show/Core.hs b/src/gen-main/haskell/Hydra/Show/Core.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Show/Core.hs +++ /dev/null @@ -1,459 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | String representations of hydra.core types - -module Hydra.Show.Core where - -import qualified Hydra.Core as Core -import qualified Hydra.Lib.Eithers as Eithers -import qualified Hydra.Lib.Lists as Lists -import qualified Hydra.Lib.Literals as Literals -import qualified Hydra.Lib.Logic as Logic -import qualified Hydra.Lib.Maps as Maps -import qualified Hydra.Lib.Maybes as Maybes -import qualified Hydra.Lib.Pairs as Pairs -import qualified Hydra.Lib.Sets as Sets -import qualified Hydra.Lib.Strings as Strings -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | Show a binding as a string -binding :: Core.Binding -> String -binding el = - - let name = Core.unName (Core.bindingName el) - t = Core.bindingTerm el - typeStr = - Maybes.maybe "" (\ts -> Strings.cat [ - ":(", - (typeScheme ts), - ")"]) (Core.bindingType el) - in (Strings.cat [ - name, - typeStr, - " = ", - (term t)]) - --- | Show an elimination as a string -elimination :: Core.Elimination -> String -elimination elm = - case elm of - Core.EliminationRecord v0 -> - let tname = Core.unName (Core.projectionTypeName v0) - fname = Core.unName (Core.projectionField v0) - in (Strings.cat [ - "project(", - tname, - "){", - fname, - "}"]) - Core.EliminationUnion v0 -> - let tname = Core.unName (Core.caseStatementTypeName v0) - mdef = Core.caseStatementDefault v0 - cases = Core.caseStatementCases v0 - defaultField = - Maybes.maybe [] (\d -> [ - Core.Field { - Core.fieldName = (Core.Name "[default]"), - Core.fieldTerm = d}]) mdef - allFields = - Lists.concat [ - cases, - defaultField] - in (Strings.cat [ - "case(", - tname, - ")", - (fields allFields)]) - Core.EliminationWrap v0 -> Strings.cat [ - "unwrap(", - (Core.unName v0), - ")"] - -field :: Core.Field -> String -field field = - - let fname = Core.unName (Core.fieldName field) - fterm = Core.fieldTerm field - in (Strings.cat [ - fname, - "=", - (term fterm)]) - -fieldType :: Core.FieldType -> String -fieldType ft = - - let fname = Core.unName (Core.fieldTypeName ft) - ftyp = Core.fieldTypeType ft - in (Strings.cat [ - fname, - ":", - (type_ ftyp)]) - --- | Show a list of fields as a string -fields :: [Core.Field] -> String -fields flds = - - let fieldStrs = Lists.map field flds - in (Strings.cat [ - "{", - (Strings.intercalate ", " fieldStrs), - "}"]) - --- | Show a float value as a string -float :: Core.FloatValue -> String -float fv = - case fv of - Core.FloatValueBigfloat v0 -> Strings.cat2 (Literals.showBigfloat v0) ":bigfloat" - Core.FloatValueFloat32 v0 -> Strings.cat2 (Literals.showFloat32 v0) ":float32" - Core.FloatValueFloat64 v0 -> Strings.cat2 (Literals.showFloat64 v0) ":float64" - --- | Show a float type as a string -floatType :: Core.FloatType -> String -floatType ft = - case ft of - Core.FloatTypeBigfloat -> "bigfloat" - Core.FloatTypeFloat32 -> "float32" - Core.FloatTypeFloat64 -> "float64" - --- | Show a function as a string -function :: Core.Function -> String -function f = - case f of - Core.FunctionElimination v0 -> elimination v0 - Core.FunctionLambda v0 -> lambda v0 - Core.FunctionPrimitive v0 -> Strings.cat2 (Core.unName v0) "!" - --- | Show an injection as a string -injection :: Core.Injection -> String -injection inj = - - let tname = Core.injectionTypeName inj - f = Core.injectionField inj - in (Strings.cat [ - "inject(", - (Core.unName tname), - ")", - (fields [ - f])]) - --- | Show an integer value as a string -integer :: Core.IntegerValue -> String -integer iv = - case iv of - Core.IntegerValueBigint v0 -> Strings.cat2 (Literals.showBigint v0) ":bigint" - Core.IntegerValueInt8 v0 -> Strings.cat2 (Literals.showInt8 v0) ":int8" - Core.IntegerValueInt16 v0 -> Strings.cat2 (Literals.showInt16 v0) ":int16" - Core.IntegerValueInt32 v0 -> Strings.cat2 (Literals.showInt32 v0) ":int32" - Core.IntegerValueInt64 v0 -> Strings.cat2 (Literals.showInt64 v0) ":int64" - Core.IntegerValueUint8 v0 -> Strings.cat2 (Literals.showUint8 v0) ":uint8" - Core.IntegerValueUint16 v0 -> Strings.cat2 (Literals.showUint16 v0) ":uint16" - Core.IntegerValueUint32 v0 -> Strings.cat2 (Literals.showUint32 v0) ":uint32" - Core.IntegerValueUint64 v0 -> Strings.cat2 (Literals.showUint64 v0) ":uint64" - --- | Show an integer type as a string -integerType :: Core.IntegerType -> String -integerType it = - case it of - Core.IntegerTypeBigint -> "bigint" - Core.IntegerTypeInt8 -> "int8" - Core.IntegerTypeInt16 -> "int16" - Core.IntegerTypeInt32 -> "int32" - Core.IntegerTypeInt64 -> "int64" - Core.IntegerTypeUint8 -> "uint8" - Core.IntegerTypeUint16 -> "uint16" - Core.IntegerTypeUint32 -> "uint32" - Core.IntegerTypeUint64 -> "uint64" - --- | Show a lambda as a string -lambda :: Core.Lambda -> String -lambda l = - - let v = Core.unName (Core.lambdaParameter l) - mt = Core.lambdaDomain l - body = Core.lambdaBody l - typeStr = Maybes.maybe "" (\t -> Strings.cat2 ":" (type_ t)) mt - in (Strings.cat [ - "\955", - v, - typeStr, - ".", - (term body)]) - --- | Show a let expression as a string -let_ :: Core.Let -> String -let_ l = - - let bindings = Core.letBindings l - env = Core.letBody l - bindingStrs = Lists.map binding bindings - in (Strings.cat [ - "let ", - (Strings.intercalate ", " bindingStrs), - " in ", - (term env)]) - --- | Show a list using a given function to show each element -list :: (t0 -> String) -> [t0] -> String -list f xs = - - let elementStrs = Lists.map f xs - in (Strings.cat [ - "[", - (Strings.intercalate ", " elementStrs), - "]"]) - --- | Show a literal as a string -literal :: Core.Literal -> String -literal l = - case l of - Core.LiteralBinary _ -> "[binary]" - Core.LiteralBoolean v0 -> Logic.ifElse v0 "true" "false" - Core.LiteralFloat v0 -> float v0 - Core.LiteralInteger v0 -> integer v0 - Core.LiteralString v0 -> Literals.showString v0 - --- | Show a literal type as a string -literalType :: Core.LiteralType -> String -literalType lt = - case lt of - Core.LiteralTypeBinary -> "binary" - Core.LiteralTypeBoolean -> "boolean" - Core.LiteralTypeFloat v0 -> floatType v0 - Core.LiteralTypeInteger v0 -> integerType v0 - Core.LiteralTypeString -> "string" - --- | A placeholder for reading terms from their serialized form. Not implemented. -readTerm :: String -> Maybe Core.Term -readTerm s = Just (Core.TermLiteral (Core.LiteralString s)) - --- | Show a term as a string -term :: Core.Term -> String -term t = - - let gatherTerms = - \prev -> \app -> - let lhs = Core.applicationFunction app - rhs = Core.applicationArgument app - in case lhs of - Core.TermApplication v0 -> gatherTerms (Lists.cons rhs prev) v0 - _ -> Lists.cons lhs (Lists.cons rhs prev) - in case t of - Core.TermAnnotated v0 -> term (Core.annotatedTermBody v0) - Core.TermApplication v0 -> - let terms = gatherTerms [] v0 - termStrs = Lists.map term terms - in (Strings.cat [ - "(", - (Strings.intercalate " @ " termStrs), - ")"]) - Core.TermEither v0 -> Eithers.either (\l -> Strings.cat [ - "left(", - (term l), - ")"]) (\r -> Strings.cat [ - "right(", - (term r), - ")"]) v0 - Core.TermFunction v0 -> function v0 - Core.TermLet v0 -> let_ v0 - Core.TermList v0 -> - let termStrs = Lists.map term v0 - in (Strings.cat [ - "[", - (Strings.intercalate ", " termStrs), - "]"]) - Core.TermLiteral v0 -> literal v0 - Core.TermMap v0 -> - let entry = - \p -> Strings.cat [ - term (Pairs.first p), - "=", - (term (Pairs.second p))] - in (Strings.cat [ - "{", - (Strings.intercalate ", " (Lists.map entry (Maps.toList v0))), - "}"]) - Core.TermMaybe v0 -> Maybes.maybe "nothing" (\t -> Strings.cat [ - "just(", - (term t), - ")"]) v0 - Core.TermPair v0 -> Strings.cat [ - "(", - (term (Pairs.first v0)), - ", ", - (term (Pairs.second v0)), - ")"] - Core.TermRecord v0 -> - let tname = Core.unName (Core.recordTypeName v0) - flds = Core.recordFields v0 - in (Strings.cat [ - "record(", - tname, - ")", - (fields flds)]) - Core.TermSet v0 -> Strings.cat [ - "{", - (Strings.intercalate ", " (Lists.map term (Sets.toList v0))), - "}"] - Core.TermTypeLambda v0 -> - let param = Core.unName (Core.typeLambdaParameter v0) - body = Core.typeLambdaBody v0 - in (Strings.cat [ - "\923", - param, - ".", - (term body)]) - Core.TermTypeApplication v0 -> - let t2 = Core.typeApplicationTermBody v0 - typ = Core.typeApplicationTermType v0 - in (Strings.cat [ - term t2, - "\10216", - (type_ typ), - "\10217"]) - Core.TermUnion v0 -> injection v0 - Core.TermUnit -> "unit" - Core.TermVariable v0 -> Core.unName v0 - Core.TermWrap v0 -> - let tname = Core.unName (Core.wrappedTermTypeName v0) - term1 = Core.wrappedTermBody v0 - in (Strings.cat [ - "wrap(", - tname, - "){", - (term term1), - "}"]) - --- | Show a type as a string -type_ :: Core.Type -> String -type_ typ = - - let showRowType = - \flds -> - let fieldStrs = Lists.map fieldType flds - in (Strings.cat [ - "{", - (Strings.intercalate ", " fieldStrs), - "}"]) - gatherTypes = - \prev -> \app -> - let lhs = Core.applicationTypeFunction app - rhs = Core.applicationTypeArgument app - in case lhs of - Core.TypeApplication v0 -> gatherTypes (Lists.cons rhs prev) v0 - _ -> Lists.cons lhs (Lists.cons rhs prev) - gatherFunctionTypes = - \prev -> \t -> case t of - Core.TypeFunction v0 -> - let dom = Core.functionTypeDomain v0 - cod = Core.functionTypeCodomain v0 - in (gatherFunctionTypes (Lists.cons dom prev) cod) - _ -> Lists.reverse (Lists.cons t prev) - in case typ of - Core.TypeAnnotated v0 -> type_ (Core.annotatedTypeBody v0) - Core.TypeApplication v0 -> - let types = gatherTypes [] v0 - typeStrs = Lists.map type_ types - in (Strings.cat [ - "(", - (Strings.intercalate " @ " typeStrs), - ")"]) - Core.TypeEither v0 -> - let leftTyp = Core.eitherTypeLeft v0 - rightTyp = Core.eitherTypeRight v0 - in (Strings.cat [ - "either<", - (type_ leftTyp), - ", ", - (type_ rightTyp), - ">"]) - Core.TypeForall v0 -> - let var = Core.unName (Core.forallTypeParameter v0) - body = Core.forallTypeBody v0 - in (Strings.cat [ - "(\8704", - var, - ".", - (type_ body), - ")"]) - Core.TypeFunction _ -> - let types = gatherFunctionTypes [] typ - typeStrs = Lists.map type_ types - in (Strings.cat [ - "(", - (Strings.intercalate " \8594 " typeStrs), - ")"]) - Core.TypeList v0 -> Strings.cat [ - "list<", - (type_ v0), - ">"] - Core.TypeLiteral v0 -> literalType v0 - Core.TypeMap v0 -> - let keyTyp = Core.mapTypeKeys v0 - valTyp = Core.mapTypeValues v0 - in (Strings.cat [ - "map<", - (type_ keyTyp), - ", ", - (type_ valTyp), - ">"]) - Core.TypeMaybe v0 -> Strings.cat [ - "maybe<", - (type_ v0), - ">"] - Core.TypePair v0 -> - let firstTyp = Core.pairTypeFirst v0 - secondTyp = Core.pairTypeSecond v0 - in (Strings.cat [ - "(", - (type_ firstTyp), - ", ", - (type_ secondTyp), - ")"]) - Core.TypeRecord v0 -> Strings.cat2 "record" (showRowType v0) - Core.TypeSet v0 -> Strings.cat [ - "set<", - (type_ v0), - ">"] - Core.TypeUnion v0 -> Strings.cat2 "union" (showRowType v0) - Core.TypeUnit -> "unit" - Core.TypeVariable v0 -> Core.unName v0 - Core.TypeVoid -> "void" - Core.TypeWrap v0 -> Strings.cat [ - "wrap(", - (type_ v0), - ")"] - --- | Show a type scheme as a string -typeScheme :: Core.TypeScheme -> String -typeScheme ts = - - let vars = Core.typeSchemeVariables ts - body = Core.typeSchemeType ts - varNames = Lists.map Core.unName vars - fa = - Logic.ifElse (Lists.null vars) "" (Strings.cat [ - "forall ", - (Strings.intercalate "," varNames), - ". "]) - toConstraintPair = - \v -> \c -> Strings.cat [ - Core.unName c, - " ", - (Core.unName v)] - toConstraintPairs = - \p -> Lists.map (toConstraintPair (Pairs.first p)) (Sets.toList (Core.typeVariableMetadataClasses (Pairs.second p))) - tc = Maybes.maybe [] (\m -> Lists.concat (Lists.map toConstraintPairs (Maps.toList m))) (Core.typeSchemeConstraints ts) - in (Strings.cat [ - "(", - fa, - (Logic.ifElse (Lists.null tc) "" (Strings.cat [ - "(", - (Strings.intercalate ", " tc), - ") => "])), - (type_ body), - ")"]) diff --git a/src/gen-main/haskell/Hydra/Show/Error/Core.hs b/src/gen-main/haskell/Hydra/Show/Error/Core.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Show/Error/Core.hs +++ /dev/null @@ -1,323 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | String representations of hydra.error.core types - -module Hydra.Show.Error.Core where - -import qualified Hydra.Core as Core -import qualified Hydra.Error.Core as Core_ -import qualified Hydra.Lib.Literals as Literals -import qualified Hydra.Lib.Strings as Strings -import qualified Hydra.Show.Core as Core__ -import qualified Hydra.Show.Meta as Meta -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | Show a constant condition error as a string -constantConditionError :: Core_.ConstantConditionError -> String -constantConditionError e = - Strings.cat [ - "constant condition: ifElse with literal ", - (Literals.showBoolean (Core_.constantConditionErrorValue e))] - --- | Show a duplicate binding error as a string -duplicateBindingError :: Core_.DuplicateBindingError -> String -duplicateBindingError e = - Strings.cat [ - "duplicate binding: ", - (Core.unName (Core_.duplicateBindingErrorName e))] - --- | Show a duplicate field error as a string -duplicateFieldError :: Core_.DuplicateFieldError -> String -duplicateFieldError e = - Strings.cat [ - "duplicate field: ", - (Core.unName (Core_.duplicateFieldErrorName e))] - --- | Show a duplicate record type field names error as a string -duplicateRecordTypeFieldNamesError :: Core_.DuplicateRecordTypeFieldNamesError -> String -duplicateRecordTypeFieldNamesError e = - Strings.cat [ - "duplicate field in record type: ", - (Core.unName (Core_.duplicateRecordTypeFieldNamesErrorName e))] - --- | Show a duplicate union type field names error as a string -duplicateUnionTypeFieldNamesError :: Core_.DuplicateUnionTypeFieldNamesError -> String -duplicateUnionTypeFieldNamesError e = - Strings.cat [ - "duplicate field in union type: ", - (Core.unName (Core_.duplicateUnionTypeFieldNamesErrorName e))] - --- | Show an empty case statement error as a string -emptyCaseStatementError :: Core_.EmptyCaseStatementError -> String -emptyCaseStatementError e = - Strings.cat [ - "empty case statement for type: ", - (Core.unName (Core_.emptyCaseStatementErrorTypeName e))] - --- | Show an empty let bindings error as a string -emptyLetBindingsError :: t0 -> String -emptyLetBindingsError e = "let expression with no bindings" - --- | Show an empty record type error as a string -emptyRecordTypeError :: t0 -> String -emptyRecordTypeError e = "record type with no fields (use TypeUnit instead)" - --- | Show an empty term annotation error as a string -emptyTermAnnotationError :: t0 -> String -emptyTermAnnotationError e = "term annotation with empty annotation map" - --- | Show an empty type annotation error as a string -emptyTypeAnnotationError :: t0 -> String -emptyTypeAnnotationError e = "type annotation with empty annotation map" - --- | Show an empty type name in term error as a string -emptyTypeNameInTermError :: t0 -> String -emptyTypeNameInTermError e = "term with empty type name" - --- | Show an empty union type error as a string -emptyUnionTypeError :: t0 -> String -emptyUnionTypeError e = "union type with no alternatives (use TypeVoid instead)" - --- | Show an invalid forall parameter name error as a string -invalidForallParameterNameError :: Core_.InvalidForallParameterNameError -> String -invalidForallParameterNameError e = - Strings.cat [ - "invalid forall parameter name: ", - (Core.unName (Core_.invalidForallParameterNameErrorName e))] - --- | Show an invalid lambda parameter name error as a string -invalidLambdaParameterNameError :: Core_.InvalidLambdaParameterNameError -> String -invalidLambdaParameterNameError e = - Strings.cat [ - "invalid lambda parameter name: ", - (Core.unName (Core_.invalidLambdaParameterNameErrorName e))] - --- | Show an invalid let binding name error as a string -invalidLetBindingNameError :: Core_.InvalidLetBindingNameError -> String -invalidLetBindingNameError e = - Strings.cat [ - "invalid let binding name: ", - (Core.unName (Core_.invalidLetBindingNameErrorName e))] - --- | Show an invalid term error as a string -invalidTermError :: Core_.InvalidTermError -> String -invalidTermError e = - Strings.cat2 "invalid term: " (case e of - Core_.InvalidTermErrorConstantCondition v0 -> constantConditionError v0 - Core_.InvalidTermErrorDuplicateBinding v0 -> duplicateBindingError v0 - Core_.InvalidTermErrorDuplicateField v0 -> duplicateFieldError v0 - Core_.InvalidTermErrorEmptyCaseStatement v0 -> emptyCaseStatementError v0 - Core_.InvalidTermErrorEmptyLetBindings v0 -> emptyLetBindingsError v0 - Core_.InvalidTermErrorEmptyTermAnnotation v0 -> emptyTermAnnotationError v0 - Core_.InvalidTermErrorEmptyTypeNameInTerm v0 -> emptyTypeNameInTermError v0 - Core_.InvalidTermErrorInvalidLambdaParameterName v0 -> invalidLambdaParameterNameError v0 - Core_.InvalidTermErrorInvalidLetBindingName v0 -> invalidLetBindingNameError v0 - Core_.InvalidTermErrorInvalidTypeLambdaParameterName v0 -> invalidTypeLambdaParameterNameError v0 - Core_.InvalidTermErrorNestedTermAnnotation v0 -> nestedTermAnnotationError v0 - Core_.InvalidTermErrorRedundantWrapUnwrap v0 -> redundantWrapUnwrapError v0 - Core_.InvalidTermErrorSelfApplication v0 -> selfApplicationError v0 - Core_.InvalidTermErrorTermVariableShadowing v0 -> termVariableShadowingError v0 - Core_.InvalidTermErrorTypeVariableShadowingInTypeLambda v0 -> typeVariableShadowingInTypeLambdaError v0 - Core_.InvalidTermErrorUndefinedTermVariable v0 -> undefinedTermVariableError v0 - Core_.InvalidTermErrorUndefinedTypeVariableInBindingType v0 -> undefinedTypeVariableInBindingTypeError v0 - Core_.InvalidTermErrorUndefinedTypeVariableInLambdaDomain v0 -> undefinedTypeVariableInLambdaDomainError v0 - Core_.InvalidTermErrorUndefinedTypeVariableInTypeApplication v0 -> undefinedTypeVariableInTypeApplicationError v0 - Core_.InvalidTermErrorUnknownPrimitiveName v0 -> unknownPrimitiveNameError v0 - Core_.InvalidTermErrorUnnecessaryIdentityApplication v0 -> unnecessaryIdentityApplicationError v0 - Core_.InvalidTermErrorUntypedTermVariable v0 -> untypedTermVariableError v0) - --- | Show an invalid type error as a string -invalidTypeError :: Core_.InvalidTypeError -> String -invalidTypeError e = - Strings.cat2 "invalid type: " (case e of - Core_.InvalidTypeErrorDuplicateRecordTypeFieldNames v0 -> duplicateRecordTypeFieldNamesError v0 - Core_.InvalidTypeErrorDuplicateUnionTypeFieldNames v0 -> duplicateUnionTypeFieldNamesError v0 - Core_.InvalidTypeErrorEmptyRecordType v0 -> emptyRecordTypeError v0 - Core_.InvalidTypeErrorEmptyTypeAnnotation v0 -> emptyTypeAnnotationError v0 - Core_.InvalidTypeErrorEmptyUnionType v0 -> emptyUnionTypeError v0 - Core_.InvalidTypeErrorInvalidForallParameterName v0 -> invalidForallParameterNameError v0 - Core_.InvalidTypeErrorInvalidTypeSchemeVariableName v0 -> invalidTypeSchemeVariableNameError v0 - Core_.InvalidTypeErrorNestedTypeAnnotation v0 -> nestedTypeAnnotationError v0 - Core_.InvalidTypeErrorNonComparableMapKeyType v0 -> nonComparableMapKeyTypeError v0 - Core_.InvalidTypeErrorNonComparableSetElementType v0 -> nonComparableSetElementTypeError v0 - Core_.InvalidTypeErrorSingleVariantUnion v0 -> singleVariantUnionError v0 - Core_.InvalidTypeErrorTypeVariableShadowingInForall v0 -> typeVariableShadowingInForallError v0 - Core_.InvalidTypeErrorUndefinedTypeVariable v0 -> undefinedTypeVariableError v0 - Core_.InvalidTypeErrorVoidInNonBottomPosition v0 -> voidInNonBottomPositionError v0) - --- | Show an invalid type lambda parameter name error as a string -invalidTypeLambdaParameterNameError :: Core_.InvalidTypeLambdaParameterNameError -> String -invalidTypeLambdaParameterNameError e = - Strings.cat [ - "invalid type lambda parameter name: ", - (Core.unName (Core_.invalidTypeLambdaParameterNameErrorName e))] - --- | Show an invalid type scheme variable name error as a string -invalidTypeSchemeVariableNameError :: Core_.InvalidTypeSchemeVariableNameError -> String -invalidTypeSchemeVariableNameError e = - Strings.cat [ - "invalid type scheme variable name: ", - (Core.unName (Core_.invalidTypeSchemeVariableNameErrorName e))] - --- | Show a nested term annotation error as a string -nestedTermAnnotationError :: t0 -> String -nestedTermAnnotationError e = "nested term annotations should be merged" - --- | Show a nested type annotation error as a string -nestedTypeAnnotationError :: t0 -> String -nestedTypeAnnotationError e = "nested type annotations should be merged" - --- | Show a non-comparable map key type error as a string -nonComparableMapKeyTypeError :: Core_.NonComparableMapKeyTypeError -> String -nonComparableMapKeyTypeError e = - Strings.cat [ - "map key type contains a function type: ", - (Core__.type_ (Core_.nonComparableMapKeyTypeErrorKeyType e))] - --- | Show a non-comparable set element type error as a string -nonComparableSetElementTypeError :: Core_.NonComparableSetElementTypeError -> String -nonComparableSetElementTypeError e = - Strings.cat [ - "set element type contains a function type: ", - (Core__.type_ (Core_.nonComparableSetElementTypeErrorElementType e))] - --- | Show a redundant wrap/unwrap error as a string -redundantWrapUnwrapError :: Core_.RedundantWrapUnwrapError -> String -redundantWrapUnwrapError e = - Strings.cat [ - "redundant wrap/unwrap for type: ", - (Core.unName (Core_.redundantWrapUnwrapErrorTypeName e))] - --- | Show a self-application error as a string -selfApplicationError :: Core_.SelfApplicationError -> String -selfApplicationError e = - Strings.cat [ - "self-application of variable: ", - (Core.unName (Core_.selfApplicationErrorName e))] - --- | Show a single variant union error as a string -singleVariantUnionError :: Core_.SingleVariantUnionError -> String -singleVariantUnionError e = - Strings.cat [ - "union type with single variant: ", - (Core.unName (Core_.singleVariantUnionErrorFieldName e))] - --- | Show a term variable shadowing error as a string -termVariableShadowingError :: Core_.TermVariableShadowingError -> String -termVariableShadowingError e = - Strings.cat [ - "variable shadowing: ", - (Core.unName (Core_.termVariableShadowingErrorName e))] - --- | Show a type variable shadowing in forall error as a string -typeVariableShadowingInForallError :: Core_.TypeVariableShadowingInForallError -> String -typeVariableShadowingInForallError e = - Strings.cat [ - "type variable shadowing in forall: ", - (Core.unName (Core_.typeVariableShadowingInForallErrorName e))] - --- | Show a type variable shadowing in type lambda error as a string -typeVariableShadowingInTypeLambdaError :: Core_.TypeVariableShadowingInTypeLambdaError -> String -typeVariableShadowingInTypeLambdaError e = - Strings.cat [ - "type variable shadowing in type lambda: ", - (Core.unName (Core_.typeVariableShadowingInTypeLambdaErrorName e))] - --- | Show an undefined field error as a string -undefinedFieldError :: Core_.UndefinedFieldError -> String -undefinedFieldError e = - - let fname = Core_.undefinedFieldErrorFieldName e - tname = Core_.undefinedFieldErrorTypeName e - in (Strings.cat [ - "no such field \"", - (Core.unName fname), - "\" in type \"", - (Core.unName tname), - "\""]) - --- | Show an undefined term variable error as a string -undefinedTermVariableError :: Core_.UndefinedTermVariableError -> String -undefinedTermVariableError e = - Strings.cat [ - "undefined term variable: ", - (Core.unName (Core_.undefinedTermVariableErrorName e))] - --- | Show an undefined type variable error as a string -undefinedTypeVariableError :: Core_.UndefinedTypeVariableError -> String -undefinedTypeVariableError e = - Strings.cat [ - "undefined type variable: ", - (Core.unName (Core_.undefinedTypeVariableErrorName e))] - --- | Show an undefined type variable in binding type error as a string -undefinedTypeVariableInBindingTypeError :: Core_.UndefinedTypeVariableInBindingTypeError -> String -undefinedTypeVariableInBindingTypeError e = - Strings.cat [ - "undefined type variable in binding type: ", - (Core.unName (Core_.undefinedTypeVariableInBindingTypeErrorName e))] - --- | Show an undefined type variable in lambda domain error as a string -undefinedTypeVariableInLambdaDomainError :: Core_.UndefinedTypeVariableInLambdaDomainError -> String -undefinedTypeVariableInLambdaDomainError e = - Strings.cat [ - "undefined type variable in lambda domain: ", - (Core.unName (Core_.undefinedTypeVariableInLambdaDomainErrorName e))] - --- | Show an undefined type variable in type application error as a string -undefinedTypeVariableInTypeApplicationError :: Core_.UndefinedTypeVariableInTypeApplicationError -> String -undefinedTypeVariableInTypeApplicationError e = - Strings.cat [ - "undefined type variable in type application: ", - (Core.unName (Core_.undefinedTypeVariableInTypeApplicationErrorName e))] - --- | Show an unexpected term variant error as a string -unexpectedTermVariantError :: Core_.UnexpectedTermVariantError -> String -unexpectedTermVariantError e = - - let expected = Core_.unexpectedTermVariantErrorExpectedVariant e - actual = Core_.unexpectedTermVariantErrorActualTerm e - in (Strings.cat [ - "expected ", - (Meta.termVariant expected), - " term but found ", - (Core__.term actual)]) - --- | Show an unexpected type variant error as a string -unexpectedTypeVariantError :: Core_.UnexpectedTypeVariantError -> String -unexpectedTypeVariantError e = - - let expected = Core_.unexpectedTypeVariantErrorExpectedVariant e - actual = Core_.unexpectedTypeVariantErrorActualType e - in (Strings.cat [ - "expected ", - (Meta.typeVariant expected), - " type but found ", - (Core__.type_ actual)]) - --- | Show an unknown primitive name error as a string -unknownPrimitiveNameError :: Core_.UnknownPrimitiveNameError -> String -unknownPrimitiveNameError e = - Strings.cat [ - "unknown primitive: ", - (Core.unName (Core_.unknownPrimitiveNameErrorName e))] - --- | Show an unnecessary identity application error as a string -unnecessaryIdentityApplicationError :: t0 -> String -unnecessaryIdentityApplicationError e = "unnecessary application of identity lambda" - --- | Show an untyped term variable error as a string -untypedTermVariableError :: Core_.UntypedTermVariableError -> String -untypedTermVariableError e = - Strings.cat [ - "untyped term variable: ", - (Core.unName (Core_.untypedTermVariableErrorName e))] - --- | Show a void in non-bottom position error as a string -voidInNonBottomPositionError :: t0 -> String -voidInNonBottomPositionError e = "TypeVoid in a position where no value can be constructed" diff --git a/src/gen-main/haskell/Hydra/Show/Errors.hs b/src/gen-main/haskell/Hydra/Show/Errors.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Show/Errors.hs +++ /dev/null @@ -1,176 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | String representations of hydra.error types - -module Hydra.Show.Errors where - -import qualified Hydra.Core as Core -import qualified Hydra.Error.Checking as Checking -import qualified Hydra.Errors as Errors -import qualified Hydra.Formatting as Formatting -import qualified Hydra.Lib.Lists as Lists -import qualified Hydra.Lib.Literals as Literals -import qualified Hydra.Lib.Sets as Sets -import qualified Hydra.Lib.Strings as Strings -import qualified Hydra.Show.Core as Core_ -import qualified Hydra.Show.Error.Core as Core__ -import qualified Hydra.Show.Meta as Meta -import qualified Hydra.Show.Typing as Typing -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | Show a checking error as a string -checkingError :: Checking.CheckingError -> String -checkingError ce = - case ce of - Checking.CheckingErrorIncorrectUnification v0 -> incorrectUnificationError v0 - Checking.CheckingErrorNotAForallType v0 -> notAForallTypeError v0 - Checking.CheckingErrorNotAFunctionType v0 -> notAFunctionTypeError v0 - Checking.CheckingErrorTypeArityMismatch v0 -> typeArityMismatchError v0 - Checking.CheckingErrorTypeMismatch v0 -> typeMismatchError v0 - Checking.CheckingErrorUnboundTypeVariables v0 -> unboundTypeVariablesError v0 - Checking.CheckingErrorUnequalTypes v0 -> unequalTypesError v0 - Checking.CheckingErrorUnsupportedTermVariant v0 -> unsupportedTermVariantError v0 - Checking.CheckingErrorUntypedLambda v0 -> untypedLambdaError v0 - Checking.CheckingErrorUntypedLetBinding v0 -> untypedLetBindingError v0 - --- | Show a decoding error as a string -decodingError :: Errors.DecodingError -> String -decodingError de = Strings.cat2 "decoding error: " (Errors.unDecodingError de) - --- | Show an error as a string -error :: Errors.Error -> String -error e = - case e of - Errors.ErrorChecking v0 -> checkingError v0 - Errors.ErrorDecoding v0 -> decodingError v0 - Errors.ErrorDuplicateBinding v0 -> Core__.duplicateBindingError v0 - Errors.ErrorDuplicateField v0 -> Core__.duplicateFieldError v0 - Errors.ErrorOther v0 -> otherError v0 - Errors.ErrorUndefinedField v0 -> Core__.undefinedFieldError v0 - Errors.ErrorUndefinedTermVariable v0 -> Core__.undefinedTermVariableError v0 - Errors.ErrorUntypedTermVariable v0 -> Core__.untypedTermVariableError v0 - Errors.ErrorUnexpectedTermVariant v0 -> Core__.unexpectedTermVariantError v0 - Errors.ErrorUnexpectedTypeVariant v0 -> Core__.unexpectedTypeVariantError v0 - Errors.ErrorUnification v0 -> unificationError v0 - --- | Show an incorrect unification error as a string -incorrectUnificationError :: Checking.IncorrectUnificationError -> String -incorrectUnificationError e = - - let subst = Checking.incorrectUnificationErrorSubstitution e - in (Strings.cat2 "incorrect unification: " (Typing.typeSubst subst)) - --- | Show a not-a-forall-type error as a string -notAForallTypeError :: Checking.NotAForallTypeError -> String -notAForallTypeError e = - - let typ = Checking.notAForallTypeErrorType e - args = Checking.notAForallTypeErrorTypeArguments e - in (Strings.cat [ - "not a forall type: ", - (Core_.type_ typ), - ". Trying to apply ", - (Literals.showInt32 (Lists.length args)), - " type argument(s): ", - (Formatting.showList Core_.type_ args)]) - --- | Show a not-a-function-type error as a string -notAFunctionTypeError :: Checking.NotAFunctionTypeError -> String -notAFunctionTypeError e = - - let typ = Checking.notAFunctionTypeErrorType e - in (Strings.cat2 "not a function type: " (Core_.type_ typ)) - --- | Show an other error as a string -otherError :: Errors.OtherError -> String -otherError oe = Errors.unOtherError oe - --- | Show a type arity mismatch error as a string -typeArityMismatchError :: Checking.TypeArityMismatchError -> String -typeArityMismatchError e = - - let typ = Checking.typeArityMismatchErrorType e - expected = Checking.typeArityMismatchErrorExpectedArity e - actual = Checking.typeArityMismatchErrorActualArity e - args = Checking.typeArityMismatchErrorTypeArguments e - in (Strings.cat [ - "type ", - (Core_.type_ typ), - " applied to the wrong number of type arguments (expected ", - (Literals.showInt32 expected), - ", got ", - (Literals.showInt32 actual), - "): ", - (Formatting.showList Core_.type_ args)]) - --- | Show a type mismatch error as a string -typeMismatchError :: Checking.TypeMismatchError -> String -typeMismatchError e = - - let expected = Checking.typeMismatchErrorExpectedType e - actual = Checking.typeMismatchErrorActualType e - in (Strings.cat [ - "type mismatch: expected ", - (Core_.type_ expected), - " but found ", - (Core_.type_ actual)]) - --- | Show an unbound type variables error as a string -unboundTypeVariablesError :: Checking.UnboundTypeVariablesError -> String -unboundTypeVariablesError e = - - let vars = Checking.unboundTypeVariablesErrorVariables e - typ = Checking.unboundTypeVariablesErrorType e - in (Strings.cat [ - "unbound type variables: {", - (Strings.intercalate ", " (Lists.map Core.unName (Sets.toList vars))), - "} in type ", - (Core_.type_ typ)]) - --- | Show an unequal types error as a string -unequalTypesError :: Checking.UnequalTypesError -> String -unequalTypesError e = - - let types = Checking.unequalTypesErrorTypes e - desc = Checking.unequalTypesErrorDescription e - in (Strings.cat [ - "unequal types ", - (Formatting.showList Core_.type_ types), - " in ", - desc]) - --- | Show a unification error as a string -unificationError :: Errors.UnificationError -> String -unificationError e = - - let lt = Errors.unificationErrorLeftType e - rt = Errors.unificationErrorRightType e - msg = Errors.unificationErrorMessage e - in (Strings.cat [ - "unification error: cannot unify ", - (Core_.type_ lt), - " with ", - (Core_.type_ rt), - ": ", - msg]) - --- | Show an unsupported term variant error as a string -unsupportedTermVariantError :: Checking.UnsupportedTermVariantError -> String -unsupportedTermVariantError e = - Strings.cat2 "unsupported term variant: " (Meta.termVariant (Checking.unsupportedTermVariantErrorTermVariant e)) - --- | Show an untyped lambda error as a string -untypedLambdaError :: t0 -> String -untypedLambdaError _ = "untyped lambda" - --- | Show an untyped let binding error as a string -untypedLetBindingError :: Checking.UntypedLetBindingError -> String -untypedLetBindingError e = - - let b = Checking.untypedLetBindingErrorBinding e - in (Strings.cat2 "untyped let binding: " (Core_.binding b)) diff --git a/src/gen-main/haskell/Hydra/Show/Graph.hs b/src/gen-main/haskell/Hydra/Show/Graph.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Show/Graph.hs +++ /dev/null @@ -1,26 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | String representations of hydra.graph types - -module Hydra.Show.Graph where - -import qualified Hydra.Core as Core -import qualified Hydra.Lib.Lists as Lists -import qualified Hydra.Lib.Strings as Strings -import qualified Hydra.Show.Core as Core_ -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | Show a list of bindings as a string -graph :: [Core.Binding] -> String -graph elements = - - let elementStrs = Lists.map Core_.binding elements - in (Strings.cat [ - "{", - (Strings.intercalate ", " elementStrs), - "}"]) diff --git a/src/gen-main/haskell/Hydra/Show/Meta.hs b/src/gen-main/haskell/Hydra/Show/Meta.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Show/Meta.hs +++ /dev/null @@ -1,58 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | String representations of hydra.meta types - -module Hydra.Show.Meta where - -import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | Show a term variant as a string -termVariant :: Variants.TermVariant -> String -termVariant x = - case x of - Variants.TermVariantAnnotated -> "annotated" - Variants.TermVariantApplication -> "application" - Variants.TermVariantEither -> "either" - Variants.TermVariantFunction -> "function" - Variants.TermVariantLet -> "let" - Variants.TermVariantList -> "list" - Variants.TermVariantLiteral -> "literal" - Variants.TermVariantMap -> "map" - Variants.TermVariantMaybe -> "maybe" - Variants.TermVariantPair -> "pair" - Variants.TermVariantRecord -> "record" - Variants.TermVariantSet -> "set" - Variants.TermVariantTypeLambda -> "typeLambda" - Variants.TermVariantTypeApplication -> "typeApplication" - Variants.TermVariantUnion -> "union" - Variants.TermVariantUnit -> "unit" - Variants.TermVariantVariable -> "variable" - Variants.TermVariantWrap -> "wrap" - --- | Show a type variant as a string -typeVariant :: Variants.TypeVariant -> String -typeVariant x = - case x of - Variants.TypeVariantAnnotated -> "annotated" - Variants.TypeVariantApplication -> "application" - Variants.TypeVariantEither -> "either" - Variants.TypeVariantForall -> "forall" - Variants.TypeVariantFunction -> "function" - Variants.TypeVariantList -> "list" - Variants.TypeVariantLiteral -> "literal" - Variants.TypeVariantMap -> "map" - Variants.TypeVariantMaybe -> "maybe" - Variants.TypeVariantPair -> "pair" - Variants.TypeVariantRecord -> "record" - Variants.TypeVariantSet -> "set" - Variants.TypeVariantUnion -> "union" - Variants.TypeVariantUnit -> "unit" - Variants.TypeVariantVariable -> "variable" - Variants.TypeVariantVoid -> "void" - Variants.TypeVariantWrap -> "wrap" diff --git a/src/gen-main/haskell/Hydra/Show/Paths.hs b/src/gen-main/haskell/Hydra/Show/Paths.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Show/Paths.hs +++ /dev/null @@ -1,118 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Utilities for working with subterm steps and paths. - -module Hydra.Show.Paths where - -import qualified Hydra.Core as Core -import qualified Hydra.Lib.Lists as Lists -import qualified Hydra.Lib.Maps as Maps -import qualified Hydra.Lib.Maybes as Maybes -import qualified Hydra.Lib.Pairs as Pairs -import qualified Hydra.Lib.Sets as Sets -import qualified Hydra.Lib.Strings as Strings -import qualified Hydra.Module as Module -import qualified Hydra.Names as Names -import qualified Hydra.Paths as Paths -import qualified Hydra.Rewriting as Rewriting -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | Convert a subterm step to a string representation -subtermStep :: Paths.SubtermStep -> Maybe String -subtermStep step = - - let idx = \i -> Nothing - idxSuff = \suffix -> \i -> Maybes.map (\s -> Strings.cat2 s suffix) (idx i) - in case step of - Paths.SubtermStepAnnotatedBody -> Nothing - Paths.SubtermStepApplicationFunction -> Just "fun" - Paths.SubtermStepApplicationArgument -> Just "arg" - Paths.SubtermStepLambdaBody -> Just "body" - Paths.SubtermStepUnionCasesDefault -> Just "default" - Paths.SubtermStepUnionCasesBranch v0 -> Just (Strings.cat2 "." (Core.unName v0)) - Paths.SubtermStepLetBody -> Just "in" - Paths.SubtermStepLetBinding v0 -> Just (Strings.cat2 (Core.unName v0) "=") - Paths.SubtermStepListElement v0 -> idx v0 - Paths.SubtermStepMapKey v0 -> idxSuff ".key" v0 - Paths.SubtermStepMapValue v0 -> idxSuff ".value" v0 - Paths.SubtermStepMaybeTerm -> Just "just" - Paths.SubtermStepProductTerm v0 -> idx v0 - Paths.SubtermStepRecordField v0 -> Just (Strings.cat2 "." (Core.unName v0)) - Paths.SubtermStepSetElement v0 -> idx v0 - Paths.SubtermStepSumTerm -> Nothing - Paths.SubtermStepTypeLambdaBody -> Nothing - Paths.SubtermStepTypeApplicationTerm -> Nothing - Paths.SubtermStepInjectionTerm -> Nothing - Paths.SubtermStepWrappedTerm -> Nothing - --- | Build a subterm graph from a term -termToSubtermGraph :: M.Map Module.Namespace String -> Core.Term -> Paths.SubtermGraph -termToSubtermGraph namespaces term = - - let dontCareStep = Paths.SubtermStepAnnotatedBody - helper = - \ids -> \mroot -> \path -> \state -> \stepTerm -> - let step = Pairs.first stepTerm - currentTerm = Pairs.second stepTerm - nodesEdges = Pairs.first state - visited = Pairs.second state - nodes = Pairs.first nodesEdges - edges = Pairs.second nodesEdges - nextPath = Lists.cons step path - in case currentTerm of - Core.TermLet v0 -> - let bindings = Core.letBindings v0 - env = Core.letBody v0 - bindingNames = Lists.map Core.bindingName bindings - addBindingName = - \nodesVisitedIds -> \name -> - let currentNodesVisited = Pairs.first nodesVisitedIds - currentIds = Pairs.second nodesVisitedIds - currentNodes = Pairs.first currentNodesVisited - currentVisited = Pairs.second currentNodesVisited - rawLabel = Names.compactName namespaces name - uniqueLabel = Names.uniqueLabel currentVisited rawLabel - node = - Paths.SubtermNode { - Paths.subtermNodeName = name, - Paths.subtermNodeLabel = rawLabel, - Paths.subtermNodeId = uniqueLabel} - newVisited = Sets.insert uniqueLabel currentVisited - newNodes = Lists.cons node currentNodes - newIds = Maps.insert name node currentIds - in ((newNodes, newVisited), newIds) - nodesVisitedIds1 = Lists.foldl addBindingName (([], visited), ids) bindingNames - nodes1 = Pairs.first (Pairs.first nodesVisitedIds1) - visited1 = Pairs.second (Pairs.first nodesVisitedIds1) - ids1 = Pairs.second nodesVisitedIds1 - addBindingTerm = - \currentState -> \nodeBinding -> - let root = Pairs.first nodeBinding - binding = Pairs.second nodeBinding - term1 = Core.bindingTerm binding - in (helper ids1 (Just root) [] currentState (dontCareStep, term1)) - nodeBindingPairs = Lists.zip nodes1 bindings - stateAfterBindings = Lists.foldl addBindingTerm ((Lists.concat2 nodes1 nodes, edges), visited1) nodeBindingPairs - in (helper ids1 mroot nextPath stateAfterBindings (Paths.SubtermStepLetBody, env)) - Core.TermVariable v0 -> Maybes.maybe state (\root -> Maybes.maybe state (\node -> - let edge = - Paths.SubtermEdge { - Paths.subtermEdgeSource = root, - Paths.subtermEdgePath = (Paths.SubtermPath (Lists.reverse nextPath)), - Paths.subtermEdgeTarget = node} - newEdges = Lists.cons edge edges - in ((nodes, newEdges), visited)) (Maps.lookup v0 ids)) mroot - _ -> Lists.foldl (helper ids mroot nextPath) state (Rewriting.subtermsWithSteps currentTerm) - initialState = (([], []), Sets.empty) - result = helper Maps.empty Nothing [] initialState (dontCareStep, term) - finalNodesEdges = Pairs.first result - finalNodes = Pairs.first finalNodesEdges - finalEdges = Pairs.second finalNodesEdges - in Paths.SubtermGraph { - Paths.subtermGraphNodes = finalNodes, - Paths.subtermGraphEdges = finalEdges} diff --git a/src/gen-main/haskell/Hydra/Show/Typing.hs b/src/gen-main/haskell/Hydra/Show/Typing.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Show/Typing.hs +++ /dev/null @@ -1,50 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | String representations of hydra.typing types - -module Hydra.Show.Typing where - -import qualified Hydra.Core as Core -import qualified Hydra.Lib.Lists as Lists -import qualified Hydra.Lib.Maps as Maps -import qualified Hydra.Lib.Pairs as Pairs -import qualified Hydra.Lib.Strings as Strings -import qualified Hydra.Show.Core as Core_ -import qualified Hydra.Typing as Typing -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | Show a type constraint as a string -typeConstraint :: Typing.TypeConstraint -> String -typeConstraint tc = - - let ltyp = Typing.typeConstraintLeft tc - rtyp = Typing.typeConstraintRight tc - in (Strings.cat [ - Core_.type_ ltyp, - "\8801", - (Core_.type_ rtyp)]) - --- | Show a type substitution as a string -typeSubst :: Typing.TypeSubst -> String -typeSubst ts = - - let subst = Typing.unTypeSubst ts - pairs = Maps.toList subst - showPair = - \pair -> - let name = Core.unName (Pairs.first pair) - typ = Pairs.second pair - in (Strings.cat [ - name, - "\8614", - (Core_.type_ typ)]) - pairStrs = Lists.map showPair pairs - in (Strings.cat [ - "{", - (Strings.intercalate "," pairStrs), - "}"]) diff --git a/src/gen-main/haskell/Hydra/Show/Util.hs b/src/gen-main/haskell/Hydra/Show/Util.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Show/Util.hs +++ /dev/null @@ -1,22 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | String representations of hydra.util types - -module Hydra.Show.Util where - -import qualified Hydra.Util as Util -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | Show a case convention as a string -caseConvention :: Util.CaseConvention -> String -caseConvention c = - case c of - Util.CaseConventionLowerSnake -> "lower_snake_case" - Util.CaseConventionUpperSnake -> "UPPER_SNAKE_CASE" - Util.CaseConventionCamel -> "camelCase" - Util.CaseConventionPascal -> "PascalCase" diff --git a/src/gen-main/haskell/Hydra/Sorting.hs b/src/gen-main/haskell/Hydra/Sorting.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Sorting.hs +++ /dev/null @@ -1,223 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Utilities for sorting. This module includes an implementation of Tarjan's algorithm, originally based on GraphSCC by Iavor S. Diatchki: https://hackage.haskell.org/package/GraphSCC. - -module Hydra.Sorting where - -import qualified Hydra.Constants as Constants -import qualified Hydra.Lib.Equality as Equality -import qualified Hydra.Lib.Lists as Lists -import qualified Hydra.Lib.Logic as Logic -import qualified Hydra.Lib.Maps as Maps -import qualified Hydra.Lib.Math as Math -import qualified Hydra.Lib.Maybes as Maybes -import qualified Hydra.Lib.Pairs as Pairs -import qualified Hydra.Lib.Sets as Sets -import qualified Hydra.Topology as Topology -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - --- | Convert an adjacency list to a map, concatenating values for duplicate keys -adjacencyListToMap :: Ord t0 => ([(t0, [t1])] -> M.Map t0 [t1]) -adjacencyListToMap pairs = - Lists.foldl (\mp -> \p -> - let k = Pairs.first p - vs = Pairs.second p - existing = Maybes.maybe [] Equality.identity (Maps.lookup k mp) - in (Maps.insert k (Lists.concat2 existing vs) mp)) Maps.empty pairs - --- | Given a list of adjacency lists represented as (key, [key]) pairs, construct a graph along with a function mapping each vertex (an Int) back to its original key. -adjacencyListsToGraph :: Ord t0 => ([(t0, [t0])] -> (M.Map Int [Int], (Int -> t0))) -adjacencyListsToGraph edges0 = - - let sortedEdges = Lists.sortOn Pairs.first edges0 - indexedEdges = Lists.zip (Math.range 0 (Lists.length sortedEdges)) sortedEdges - keyToVertex = - Maps.fromList (Lists.map (\vkNeighbors -> - let v = Pairs.first vkNeighbors - kNeighbors = Pairs.second vkNeighbors - k = Pairs.first kNeighbors - in (k, v)) indexedEdges) - vertexMap = - Maps.fromList (Lists.map (\vkNeighbors -> - let v = Pairs.first vkNeighbors - kNeighbors = Pairs.second vkNeighbors - k = Pairs.first kNeighbors - in (v, k)) indexedEdges) - graph = - Maps.fromList (Lists.map (\vkNeighbors -> - let v = Pairs.first vkNeighbors - kNeighbors = Pairs.second vkNeighbors - neighbors = Pairs.second kNeighbors - in (v, (Maybes.mapMaybe (\k -> Maps.lookup k keyToVertex) neighbors))) indexedEdges) - vertexToKey = \v -> Maybes.fromJust (Maps.lookup v vertexMap) - in (graph, vertexToKey) - -createOrderingIsomorphism :: Ord t0 => ([t0] -> [t0] -> Topology.OrderingIsomorphism t1) -createOrderingIsomorphism sourceOrd targetOrd = - - let sourceToTargetMapping = - \els -> - let mp = Maps.fromList (Lists.zip sourceOrd els) - in (Maybes.cat (Lists.map (\n -> Maps.lookup n mp) targetOrd)) - targetToSourceMapping = - \els -> - let mp = Maps.fromList (Lists.zip targetOrd els) - in (Maybes.cat (Lists.map (\n -> Maps.lookup n mp) sourceOrd)) - in Topology.OrderingIsomorphism { - Topology.orderingIsomorphismEncode = sourceToTargetMapping, - Topology.orderingIsomorphismDecode = targetToSourceMapping} - --- | Given an adjacency function and a distinguished root node, find all reachable nodes (including the root node) -findReachableNodes :: Ord t0 => ((t0 -> S.Set t0) -> t0 -> S.Set t0) -findReachableNodes adj root = - - let visit = - \visited -> \node -> - let toVisit = Sets.difference (adj node) visited - in (Logic.ifElse (Sets.null toVisit) visited (Lists.foldl (\v -> \n -> visit (Sets.insert n v) n) visited (Sets.toList toVisit))) - in (visit (Sets.singleton root) root) - --- | Initial state for Tarjan's algorithm -initialState :: Topology.TarjanState -initialState = - Topology.TarjanState { - Topology.tarjanStateCounter = 0, - Topology.tarjanStateIndices = Maps.empty, - Topology.tarjanStateLowLinks = Maps.empty, - Topology.tarjanStateStack = [], - Topology.tarjanStateOnStack = Sets.empty, - Topology.tarjanStateSccs = []} - --- | Pop vertices off the stack until the given vertex is reached, collecting the current strongly connected component -popStackUntil :: Int -> Topology.TarjanState -> ([Int], Topology.TarjanState) -popStackUntil v st0 = - - let go = - \acc -> \st -> - let x = Lists.head (Topology.tarjanStateStack st) - xs = Lists.tail (Topology.tarjanStateStack st) - newSt = - Topology.TarjanState { - Topology.tarjanStateCounter = (Topology.tarjanStateCounter st), - Topology.tarjanStateIndices = (Topology.tarjanStateIndices st), - Topology.tarjanStateLowLinks = (Topology.tarjanStateLowLinks st), - Topology.tarjanStateStack = xs, - Topology.tarjanStateOnStack = (Topology.tarjanStateOnStack st), - Topology.tarjanStateSccs = (Topology.tarjanStateSccs st)} - newSt2 = - Topology.TarjanState { - Topology.tarjanStateCounter = (Topology.tarjanStateCounter newSt), - Topology.tarjanStateIndices = (Topology.tarjanStateIndices newSt), - Topology.tarjanStateLowLinks = (Topology.tarjanStateLowLinks newSt), - Topology.tarjanStateStack = (Topology.tarjanStateStack newSt), - Topology.tarjanStateOnStack = (Sets.delete x (Topology.tarjanStateOnStack st)), - Topology.tarjanStateSccs = (Topology.tarjanStateSccs newSt)} - acc_ = Lists.cons x acc - in (Logic.ifElse (Equality.equal x v) (Lists.reverse acc_, newSt2) (go acc_ newSt2)) - in (go [] st0) - --- | Given a graph as an adjacency list of edges and a list of explicit tags per node, compute the full set of tags for each node by propagating tags through edges. If there is an edge from n1 to n2 and n2 has tag t, then n1 also has tag t. Note: pairs in the output are not ordered. -propagateTags :: (Ord t0, Ord t1) => ([(t0, [t0])] -> [(t0, [t1])] -> [(t0, (S.Set t1))]) -propagateTags edges nodeTags = - - let adjMap = adjacencyListToMap edges - tagMap = Maps.map Sets.fromList (adjacencyListToMap nodeTags) - allNodes = Sets.toList (Sets.fromList (Lists.concat2 (Lists.map Pairs.first edges) (Lists.map Pairs.first nodeTags))) - getTagsForNode = - \node -> - let reachable = findReachableNodes (\n -> Sets.fromList (Maybes.maybe [] Equality.identity (Maps.lookup n adjMap))) node - in (Sets.unions (Lists.map (\n -> Maybes.maybe Sets.empty Equality.identity (Maps.lookup n tagMap)) (Sets.toList reachable))) - in (Lists.map (\n -> (n, (getTagsForNode n))) allNodes) - --- | Visit a vertex and recursively explore its successors -strongConnect :: M.Map Int [Int] -> Int -> Topology.TarjanState -> Topology.TarjanState -strongConnect graph v st = - - let i = Topology.tarjanStateCounter st - newSt = - Topology.TarjanState { - Topology.tarjanStateCounter = (Math.add i 1), - Topology.tarjanStateIndices = (Maps.insert v i (Topology.tarjanStateIndices st)), - Topology.tarjanStateLowLinks = (Maps.insert v i (Topology.tarjanStateLowLinks st)), - Topology.tarjanStateStack = (Lists.cons v (Topology.tarjanStateStack st)), - Topology.tarjanStateOnStack = (Sets.insert v (Topology.tarjanStateOnStack st)), - Topology.tarjanStateSccs = (Topology.tarjanStateSccs st)} - neighbors = Maps.findWithDefault [] v graph - processNeighbor = - \st_ -> \w -> - let lowLink = - \s -> - let lowV1 = Maps.findWithDefault Constants.maxInt32 v (Topology.tarjanStateLowLinks s) - idx_w = Maps.findWithDefault Constants.maxInt32 w (Topology.tarjanStateIndices s) - in Topology.TarjanState { - Topology.tarjanStateCounter = (Topology.tarjanStateCounter s), - Topology.tarjanStateIndices = (Topology.tarjanStateIndices s), - Topology.tarjanStateLowLinks = (Maps.insert v (Equality.min lowV1 idx_w) (Topology.tarjanStateLowLinks s)), - Topology.tarjanStateStack = (Topology.tarjanStateStack s), - Topology.tarjanStateOnStack = (Topology.tarjanStateOnStack s), - Topology.tarjanStateSccs = (Topology.tarjanStateSccs s)} - in (Logic.ifElse (Logic.not (Maps.member w (Topology.tarjanStateIndices st_))) ( - let stAfter = strongConnect graph w st_ - lowV2 = Maps.findWithDefault Constants.maxInt32 v (Topology.tarjanStateLowLinks stAfter) - low_w = Maps.findWithDefault Constants.maxInt32 w (Topology.tarjanStateLowLinks stAfter) - in Topology.TarjanState { - Topology.tarjanStateCounter = (Topology.tarjanStateCounter stAfter), - Topology.tarjanStateIndices = (Topology.tarjanStateIndices stAfter), - Topology.tarjanStateLowLinks = (Maps.insert v (Equality.min lowV2 low_w) (Topology.tarjanStateLowLinks stAfter)), - Topology.tarjanStateStack = (Topology.tarjanStateStack stAfter), - Topology.tarjanStateOnStack = (Topology.tarjanStateOnStack stAfter), - Topology.tarjanStateSccs = (Topology.tarjanStateSccs stAfter)}) (Logic.ifElse (Sets.member w (Topology.tarjanStateOnStack st_)) (lowLink st_) st_)) - stAfterNeighbors = Lists.foldl processNeighbor newSt neighbors - low_v = Maps.findWithDefault Constants.maxInt32 v (Topology.tarjanStateLowLinks stAfterNeighbors) - idx_v = Maps.findWithDefault Constants.maxInt32 v (Topology.tarjanStateIndices stAfterNeighbors) - in (Logic.ifElse (Equality.equal low_v idx_v) ( - let compResult = popStackUntil v stAfterNeighbors - comp = Pairs.first compResult - stPopped = Pairs.second compResult - in Topology.TarjanState { - Topology.tarjanStateCounter = (Topology.tarjanStateCounter stPopped), - Topology.tarjanStateIndices = (Topology.tarjanStateIndices stPopped), - Topology.tarjanStateLowLinks = (Topology.tarjanStateLowLinks stPopped), - Topology.tarjanStateStack = (Topology.tarjanStateStack stPopped), - Topology.tarjanStateOnStack = (Topology.tarjanStateOnStack stPopped), - Topology.tarjanStateSccs = (Lists.cons comp (Topology.tarjanStateSccs stPopped))}) stAfterNeighbors) - --- | Compute the strongly connected components of the given graph. The components are returned in reverse topological order -stronglyConnectedComponents :: M.Map Int [Int] -> [[Int]] -stronglyConnectedComponents graph = - - let verts = Maps.keys graph - finalState = - Lists.foldl (\st -> \v -> Logic.ifElse (Maps.member v (Topology.tarjanStateIndices st)) st (strongConnect graph v st)) initialState verts - in (Lists.reverse (Lists.map Lists.sort (Topology.tarjanStateSccs finalState))) - --- | Sort a directed acyclic graph (DAG) based on an adjacency list. Yields a list of nontrivial strongly connected components if the graph has cycles, otherwise a simple list. -topologicalSort :: Ord t0 => ([(t0, [t0])] -> Either [[t0]] [t0]) -topologicalSort pairs = - - let sccs = topologicalSortComponents pairs - isCycle = \scc -> Logic.not (Lists.null (Lists.tail scc)) - withCycles = Lists.filter isCycle sccs - in (Logic.ifElse (Lists.null withCycles) (Right (Lists.concat sccs)) (Left withCycles)) - --- | Find the strongly connected components (including cycles and isolated vertices) of a graph, in (reverse) topological order, i.e. dependencies before dependents -topologicalSortComponents :: Ord t0 => ([(t0, [t0])] -> [[t0]]) -topologicalSortComponents pairs = - - let graphResult = adjacencyListsToGraph pairs - g = Pairs.first graphResult - in (Lists.map (\comp -> Lists.map (Pairs.second graphResult) comp) (stronglyConnectedComponents g)) - --- | Sort a directed acyclic graph (DAG) of nodes using two helper functions: one for node keys, and one for the adjacency list of connected node keys. The result is a list of strongly-connected components (cycles), in which singleton lists represent acyclic nodes. -topologicalSortNodes :: Ord t1 => ((t0 -> t1) -> (t0 -> [t1]) -> [t0] -> [[t0]]) -topologicalSortNodes getKey getAdj nodes = - - let nodesByKey = Maps.fromList (Lists.map (\n -> (getKey n, n)) nodes) - pairs = Lists.map (\n -> (getKey n, (getAdj n))) nodes - comps = topologicalSortComponents pairs - in (Lists.map (\c -> Maybes.cat (Lists.map (\k -> Maps.lookup k nodesByKey) c)) comps) diff --git a/src/gen-main/haskell/Hydra/Sources/Decode/Ast.hs b/src/gen-main/haskell/Hydra/Sources/Decode/Ast.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Sources/Decode/Ast.hs +++ /dev/null @@ -1,2193 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Source module for hydra.decode.ast - -module Hydra.Sources.Decode.Ast where - -import qualified Hydra.Core as Core -import qualified Hydra.Module as Module -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -module_ :: Module.Module -module_ = - Module.Module { - Module.moduleNamespace = (Module.Namespace "hydra.decode.ast"), - Module.moduleDefinitions = [ - Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.ast.associativity"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "union"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "inj"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "field"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionField = (Core.Name "field")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionField = (Core.Name "term")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.fromList"))), - Core.applicationArgument = (Core.TermList [ - Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "none"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.Associativity"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "none"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "left"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.Associativity"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "left"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "right"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.Associativity"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "right"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "both"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.Associativity"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "both"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))))])})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maybes.maybe"))), - Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.cat"))), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.core.Name")))), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "f"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "f")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.lookup"))), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.ast.Associativity"))}))}))})), - Core.typeSchemeConstraints = Nothing}))}), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.ast.blockStyle"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "indent"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeMaybe")), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "s"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))})))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_indent"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "newlineBeforeContent"))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected boolean literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "boolean"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "b"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "b"))))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))})))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_newlineBeforeContent"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "newlineAfterContent"))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected boolean literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "boolean"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "b"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "b"))))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))})))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_newlineAfterContent"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ast.BlockStyle"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "indent"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_indent"))}, - Core.Field { - Core.fieldName = (Core.Name "newlineBeforeContent"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_newlineBeforeContent"))}, - Core.Field { - Core.fieldName = (Core.Name "newlineAfterContent"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_newlineAfterContent"))}]}))))})))}))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.ast.BlockStyle"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.ast.bracketExpr"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "brackets"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.ast.brackets"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_brackets"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "enclosed"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.ast.expr"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_enclosed"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "style"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.ast.blockStyle"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_style"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ast.BracketExpr"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "brackets"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_brackets"))}, - Core.Field { - Core.fieldName = (Core.Name "enclosed"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_enclosed"))}, - Core.Field { - Core.fieldName = (Core.Name "style"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_style"))}]}))))})))}))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.ast.BracketExpr"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.ast.brackets"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "open"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.ast.symbol"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_open"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "close"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.ast.symbol"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_close"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ast.Brackets"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "open"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_open"))}, - Core.Field { - Core.fieldName = (Core.Name "close"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_close"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.ast.Brackets"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.ast.expr"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "union"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "inj"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "field"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionField = (Core.Name "field")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionField = (Core.Name "term")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.fromList"))), - Core.applicationArgument = (Core.TermList [ - Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "const"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.Expr"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "const"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.ast.symbol")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "indent"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.Expr"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "indent"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.ast.indentedExpression")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "op"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.Expr"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "op"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.ast.opExpr")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "brackets"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.Expr"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "brackets"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.ast.bracketExpr")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "seq"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.Expr"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "seq"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.ast.seqExpr")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))))])})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maybes.maybe"))), - Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.cat"))), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.core.Name")))), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "f"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "f")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.lookup"))), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.ast.Expr"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.ast.indentedExpression"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "style"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.ast.indentStyle"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_style"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "expr"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.ast.expr"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_expr"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ast.IndentedExpression"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "style"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_style"))}, - Core.Field { - Core.fieldName = (Core.Name "expr"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_expr"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.ast.IndentedExpression"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.ast.indentStyle"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "union"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "inj"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "field"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionField = (Core.Name "field")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionField = (Core.Name "term")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.fromList"))), - Core.applicationArgument = (Core.TermList [ - Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "allLines"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.IndentStyle"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "allLines"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "s"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "subsequentLines"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.IndentStyle"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "subsequentLines"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "s"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))))])})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maybes.maybe"))), - Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.cat"))), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.core.Name")))), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "f"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "f")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.lookup"))), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.ast.IndentStyle"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.ast.op"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "symbol"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.ast.symbol"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_symbol"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "padding"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.ast.padding"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_padding"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "precedence"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.ast.precedence"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_precedence"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "associativity"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.ast.associativity"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_associativity"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ast.Op"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "symbol"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_symbol"))}, - Core.Field { - Core.fieldName = (Core.Name "padding"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_padding"))}, - Core.Field { - Core.fieldName = (Core.Name "precedence"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_precedence"))}, - Core.Field { - Core.fieldName = (Core.Name "associativity"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_associativity"))}]}))))})))}))})))}))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.ast.Op"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.ast.opExpr"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "op"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.ast.op"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_op"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "lhs"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.ast.expr"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_lhs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "rhs"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.ast.expr"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_rhs"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ast.OpExpr"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "op"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_op"))}, - Core.Field { - Core.fieldName = (Core.Name "lhs"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_lhs"))}, - Core.Field { - Core.fieldName = (Core.Name "rhs"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_rhs"))}]}))))})))}))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.ast.OpExpr"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.ast.padding"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "left"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.ast.ws"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_left"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "right"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.ast.ws"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_right"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ast.Padding"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "left"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_left"))}, - Core.Field { - Core.fieldName = (Core.Name "right"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_right"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.ast.Padding"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.ast.precedence"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected wrapped type"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "wrap"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "wrappedTerm"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "b"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.ast.Precedence"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 value"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "int32"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "i"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i"))))})))}]}))))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.projectionField = (Core.Name "body")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "wrappedTerm"))}))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.ast.Precedence"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.ast.seqExpr"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "op"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.ast.op"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_op"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "elements"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeList")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.ast.expr"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_elements"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.ast.SeqExpr"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "op"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_op"))}, - Core.Field { - Core.fieldName = (Core.Name "elements"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_elements"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.ast.SeqExpr"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.ast.symbol"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected wrapped type"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "wrap"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "wrappedTerm"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "b"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.ast.Symbol"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "s"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.projectionField = (Core.Name "body")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "wrappedTerm"))}))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.ast.Symbol"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.ast.ws"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "union"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "inj"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "field"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionField = (Core.Name "field")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionField = (Core.Name "term")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.fromList"))), - Core.applicationArgument = (Core.TermList [ - Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "none"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.Ws"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "none"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "space"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.Ws"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "space"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "break"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.Ws"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "break"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "breakAndIndent"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.Ws"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "breakAndIndent"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "s"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "doubleBreak"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.ast.Ws"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "doubleBreak"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))))])})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maybes.maybe"))), - Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.cat"))), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.core.Name")))), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "f"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "f")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.lookup"))), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.ast.Ws"))}))}))})), - Core.typeSchemeConstraints = Nothing}))}))], - Module.moduleTermDependencies = [ - Module.Namespace "hydra.extract.helpers", - (Module.Namespace "hydra.lexical"), - (Module.Namespace "hydra.rewriting"), - (Module.Namespace "hydra.decode.core")], - Module.moduleTypeDependencies = [ - Module.Namespace "hydra.ast", - (Module.Namespace "hydra.util")], - Module.moduleDescription = (Just "Term decoders for hydra.ast")} diff --git a/src/gen-main/haskell/Hydra/Sources/Decode/Classes.hs b/src/gen-main/haskell/Hydra/Sources/Decode/Classes.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Sources/Decode/Classes.hs +++ /dev/null @@ -1,177 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Source module for hydra.decode.classes - -module Hydra.Sources.Decode.Classes where - -import qualified Hydra.Core as Core -import qualified Hydra.Module as Module -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -module_ :: Module.Module -module_ = - Module.Module { - Module.moduleNamespace = (Module.Namespace "hydra.decode.classes"), - Module.moduleDefinitions = [ - Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.classes.typeClass"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "union"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "inj"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "field"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionField = (Core.Name "field")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionField = (Core.Name "term")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.fromList"))), - Core.applicationArgument = (Core.TermList [ - Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "equality"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.classes.TypeClass"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "equality"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "ordering"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.classes.TypeClass"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "ordering"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))))])})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maybes.maybe"))), - Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.cat"))), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.core.Name")))), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "f"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "f")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.lookup"))), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.classes.TypeClass"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})], - Module.moduleTermDependencies = [ - Module.Namespace "hydra.extract.helpers", - (Module.Namespace "hydra.lexical"), - (Module.Namespace "hydra.rewriting"), - (Module.Namespace "hydra.decode.core")], - Module.moduleTypeDependencies = [ - Module.Namespace "hydra.classes", - (Module.Namespace "hydra.util")], - Module.moduleDescription = (Just "Term decoders for hydra.classes")} diff --git a/src/gen-main/haskell/Hydra/Sources/Decode/Coders.hs b/src/gen-main/haskell/Hydra/Sources/Decode/Coders.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Sources/Decode/Coders.hs +++ /dev/null @@ -1,445 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Source module for hydra.decode.coders - -module Hydra.Sources.Decode.Coders where - -import qualified Hydra.Core as Core -import qualified Hydra.Module as Module -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -module_ :: Module.Module -module_ = - Module.Module { - Module.moduleNamespace = (Module.Namespace "hydra.decode.coders"), - Module.moduleDefinitions = [ - Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.coders.coderDirection"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "union"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "inj"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "field"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionField = (Core.Name "field")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionField = (Core.Name "term")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.fromList"))), - Core.applicationArgument = (Core.TermList [ - Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "encode"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.coders.CoderDirection"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "encode"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "decode"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.coders.CoderDirection"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "decode"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))))])})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maybes.maybe"))), - Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.cat"))), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.core.Name")))), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "f"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "f")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.lookup"))), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.coders.CoderDirection"))}))}))})), - Core.typeSchemeConstraints = Nothing}))}), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.coders.languageName"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected wrapped type"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "wrap"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "wrappedTerm"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "b"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.coders.LanguageName"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "s"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.projectionField = (Core.Name "body")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "wrappedTerm"))}))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.coders.LanguageName"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.coders.traversalOrder"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "union"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "inj"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "field"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionField = (Core.Name "field")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionField = (Core.Name "term")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.fromList"))), - Core.applicationArgument = (Core.TermList [ - Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "pre"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.coders.TraversalOrder"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "pre"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "post"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.coders.TraversalOrder"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "post"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))))])})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maybes.maybe"))), - Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.cat"))), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.core.Name")))), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "f"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "f")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.lookup"))), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.coders.TraversalOrder"))}))}))})), - Core.typeSchemeConstraints = Nothing}))}))], - Module.moduleTermDependencies = [ - Module.Namespace "hydra.extract.helpers", - (Module.Namespace "hydra.lexical"), - (Module.Namespace "hydra.rewriting"), - (Module.Namespace "hydra.decode.core"), - (Module.Namespace "hydra.decode.graph"), - (Module.Namespace "hydra.decode.util"), - (Module.Namespace "hydra.decode.variants")], - Module.moduleTypeDependencies = [ - Module.Namespace "hydra.coders", - (Module.Namespace "hydra.util")], - Module.moduleDescription = (Just "Term decoders for hydra.coders")} diff --git a/src/gen-main/haskell/Hydra/Sources/Decode/Context.hs b/src/gen-main/haskell/Hydra/Sources/Decode/Context.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Sources/Decode/Context.hs +++ /dev/null @@ -1,361 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Source module for hydra.decode.context - -module Hydra.Sources.Decode.Context where - -import qualified Hydra.Core as Core -import qualified Hydra.Module as Module -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -module_ :: Module.Module -module_ = - Module.Module { - Module.moduleNamespace = (Module.Namespace "hydra.decode.context"), - Module.moduleDefinitions = [ - Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.context.context"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "trace"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeList")), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "s"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))})))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_trace"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "messages"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeList")), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "s"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))})))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_messages"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "other"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_other"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.context.Context"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "trace"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_trace"))}, - Core.Field { - Core.fieldName = (Core.Name "messages"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_messages"))}, - Core.Field { - Core.fieldName = (Core.Name "other"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_other"))}]}))))})))}))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.context.Context"))}))}))})), - Core.typeSchemeConstraints = Nothing}))}), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.context.inContext"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "e"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "object"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "e"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_object"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "context"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.context.context"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_context"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.context.InContext"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "object"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_object"))}, - Core.Field { - Core.fieldName = (Core.Name "context"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_context"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [ - Core.Name "e"], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "e"))}))}))})), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeApplication (Core.ApplicationType { - Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.context.InContext")), - Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "e"))}))}))}))}))})), - Core.typeSchemeConstraints = Nothing}))}))], - Module.moduleTermDependencies = [ - Module.Namespace "hydra.extract.helpers", - (Module.Namespace "hydra.lexical"), - (Module.Namespace "hydra.rewriting"), - (Module.Namespace "hydra.decode.core")], - Module.moduleTypeDependencies = [ - Module.Namespace "hydra.context", - (Module.Namespace "hydra.util")], - Module.moduleDescription = (Just "Term decoders for hydra.context")} diff --git a/src/gen-main/haskell/Hydra/Sources/Decode/Core.hs b/src/gen-main/haskell/Hydra/Sources/Decode/Core.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Sources/Decode/Core.hs +++ /dev/null @@ -1,5941 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Source module for hydra.decode.core - -module Hydra.Sources.Decode.Core where - -import qualified Hydra.Core as Core -import qualified Hydra.Module as Module -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -module_ :: Module.Module -module_ = - Module.Module { - Module.moduleNamespace = (Module.Namespace "hydra.decode.core"), - Module.moduleDefinitions = [ - Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.core.annotatedTerm"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "body"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_body"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "annotation"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_annotation"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.AnnotatedTerm"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_body"))}, - Core.Field { - Core.fieldName = (Core.Name "annotation"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_annotation"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.AnnotatedTerm"))}))}))})), - Core.typeSchemeConstraints = Nothing}))}), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.core.annotatedType"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "body"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_body"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "annotation"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_annotation"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.AnnotatedType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_body"))}, - Core.Field { - Core.fieldName = (Core.Name "annotation"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_annotation"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.AnnotatedType"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.core.application"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "function"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_function"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "argument"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_argument"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Application"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "function"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_function"))}, - Core.Field { - Core.fieldName = (Core.Name "argument"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_argument"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.Application"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.core.applicationType"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "function"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_function"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "argument"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_argument"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.ApplicationType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "function"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_function"))}, - Core.Field { - Core.fieldName = (Core.Name "argument"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_argument"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.ApplicationType"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.core.binding"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_name"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "term"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_term"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "type"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeMaybe")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.typeScheme"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_type"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Binding"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_term"))}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_type"))}]}))))})))}))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.Binding"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.core.caseStatement"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "typeName"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_typeName"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "default"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeMaybe")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_default"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "cases"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeList")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.field"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_cases"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.CaseStatement"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_typeName"))}, - Core.Field { - Core.fieldName = (Core.Name "default"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_default"))}, - Core.Field { - Core.fieldName = (Core.Name "cases"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_cases"))}]}))))})))}))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.CaseStatement"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.core.eitherType"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "left"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_left"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "right"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_right"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.EitherType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "left"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_left"))}, - Core.Field { - Core.fieldName = (Core.Name "right"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_right"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.EitherType"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.core.pairType"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "first"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_first"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "second"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_second"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.PairType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "first"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_first"))}, - Core.Field { - Core.fieldName = (Core.Name "second"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_second"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.PairType"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.core.elimination"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "union"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "inj"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "field"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionField = (Core.Name "field")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionField = (Core.Name "term")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.fromList"))), - Core.applicationArgument = (Core.TermList [ - Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "record"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Elimination"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.projection")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "union"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Elimination"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "union"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.caseStatement")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "wrap"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Elimination"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wrap"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))))])})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maybes.maybe"))), - Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.cat"))), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.core.Name")))), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "f"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "f")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.lookup"))), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.Elimination"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.core.field"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_name"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "term"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_term"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Field"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}, - Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_term"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.Field"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.core.fieldType"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_name"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "type"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_type"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.FieldType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_type"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.FieldType"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.core.floatType"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "union"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "inj"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "field"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionField = (Core.Name "field")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionField = (Core.Name "term")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.fromList"))), - Core.applicationArgument = (Core.TermList [ - Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "bigfloat"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.FloatType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "bigfloat"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "float32"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.FloatType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "float32"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "float64"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.FloatType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "float64"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))))])})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maybes.maybe"))), - Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.cat"))), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.core.Name")))), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "f"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "f")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.lookup"))), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.FloatType"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.core.floatValue"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "union"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "inj"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "field"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionField = (Core.Name "field")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionField = (Core.Name "term")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.fromList"))), - Core.applicationArgument = (Core.TermList [ - Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "bigfloat"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.FloatValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "bigfloat"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected bigfloat literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "float"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.FloatValue"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected bigfloat value"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "bigfloat"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "f"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "f"))))})))}]}))))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "float32"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.FloatValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "float32"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected float32 literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "float"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.FloatValue"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected float32 value"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "float32"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "f"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "f"))))})))}]}))))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "float64"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.FloatValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "float64"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected float64 literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "float"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.FloatValue"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected float64 value"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "float64"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "f"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "f"))))})))}]}))))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))))])})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maybes.maybe"))), - Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.cat"))), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.core.Name")))), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "f"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "f")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.lookup"))), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.FloatValue"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.core.forallType"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "parameter"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_parameter"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "body"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_body"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.ForallType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "parameter"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_parameter"))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_body"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.ForallType"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.core.function"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "union"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "inj"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "field"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionField = (Core.Name "field")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionField = (Core.Name "term")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.fromList"))), - Core.applicationArgument = (Core.TermList [ - Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "elimination"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Function"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "elimination"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.elimination")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "lambda"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Function"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "lambda"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.lambda")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "primitive"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Function"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "primitive"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))))])})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maybes.maybe"))), - Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.cat"))), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.core.Name")))), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "f"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "f")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.lookup"))), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.Function"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.core.functionType"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "domain"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_domain"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "codomain"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_codomain"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.FunctionType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "domain"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_domain"))}, - Core.Field { - Core.fieldName = (Core.Name "codomain"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_codomain"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.FunctionType"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.core.injection"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "typeName"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_typeName"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "field"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.field"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_field"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Injection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_typeName"))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_field"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.Injection"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.core.integerType"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "union"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "inj"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "field"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionField = (Core.Name "field")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionField = (Core.Name "term")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.fromList"))), - Core.applicationArgument = (Core.TermList [ - Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "bigint"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "bigint"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "int8"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int8"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "int16"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int16"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "int32"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int32"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "int64"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int64"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "uint8"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "uint8"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "uint16"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "uint16"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "uint32"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "uint32"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "uint64"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "uint64"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))))])})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maybes.maybe"))), - Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.cat"))), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.core.Name")))), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "f"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "f")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.lookup"))), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.IntegerType"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.core.integerValue"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "union"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "inj"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "field"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionField = (Core.Name "field")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionField = (Core.Name "term")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.fromList"))), - Core.applicationArgument = (Core.TermList [ - Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "bigint"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "bigint"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected bigint literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected bigint value"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "bigint"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "i"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i"))))})))}]}))))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "int8"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int8"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int8 literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int8 value"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "int8"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "i"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i"))))})))}]}))))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "int16"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int16"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int16 literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int16 value"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "int16"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "i"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i"))))})))}]}))))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "int32"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int32"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 value"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "int32"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "i"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i"))))})))}]}))))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "int64"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "int64"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int64 literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int64 value"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "int64"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "i"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i"))))})))}]}))))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "uint8"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "uint8"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected uint8 literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected uint8 value"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "uint8"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "i"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i"))))})))}]}))))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "uint16"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "uint16"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected uint16 literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected uint16 value"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "uint16"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "i"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i"))))})))}]}))))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "uint32"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "uint32"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected uint32 literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected uint32 value"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "uint32"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "i"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i"))))})))}]}))))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "uint64"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "uint64"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected uint64 literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected uint64 value"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "uint64"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "i"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i"))))})))}]}))))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))))])})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maybes.maybe"))), - Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.cat"))), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.core.Name")))), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "f"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "f")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.lookup"))), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.IntegerValue"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.core.lambda"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "parameter"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_parameter"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "domain"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeMaybe")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_domain"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "body"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_body"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Lambda"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "parameter"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_parameter"))}, - Core.Field { - Core.fieldName = (Core.Name "domain"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_domain"))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_body"))}]}))))})))}))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.Lambda"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.core.let"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "bindings"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeList")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.binding"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_bindings"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "body"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_body"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Let"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "bindings"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_bindings"))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_body"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.Let"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.core.literal"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "union"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "inj"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "field"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionField = (Core.Name "field")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionField = (Core.Name "term")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.fromList"))), - Core.applicationArgument = (Core.TermList [ - Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "binary"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "binary"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected binary literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "binary"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "b"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "b"))))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "boolean"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "boolean"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected boolean literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "boolean"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "b"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "b"))))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "float"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "float"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.floatValue")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "integer"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.integerValue")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "string"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Literal"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "s"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))))])})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maybes.maybe"))), - Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.cat"))), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.core.Name")))), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "f"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "f")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.lookup"))), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.Literal"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.core.literalType"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "union"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "inj"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "field"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionField = (Core.Name "field")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionField = (Core.Name "term")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.fromList"))), - Core.applicationArgument = (Core.TermList [ - Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "binary"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.LiteralType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "binary"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "boolean"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.LiteralType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "boolean"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "float"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.LiteralType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "float"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.floatType")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "integer"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.LiteralType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.integerType")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "string"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.LiteralType"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))))])})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maybes.maybe"))), - Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.cat"))), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.core.Name")))), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "f"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "f")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.lookup"))), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.LiteralType"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.core.mapType"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "keys"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_keys"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "values"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_values"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.MapType"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "keys"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_keys"))}, - Core.Field { - Core.fieldName = (Core.Name "values"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_values"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.MapType"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.core.name"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected wrapped type"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "wrap"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "wrappedTerm"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "b"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "s"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.projectionField = (Core.Name "body")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "wrappedTerm"))}))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.Name"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.core.projection"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "typeName"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_typeName"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "field"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_field"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Projection"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_typeName"))}, - Core.Field { - Core.fieldName = (Core.Name "field"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_field"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.Projection"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.core.record"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "typeName"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_typeName"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "fields"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeList")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.field"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_fields"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.Record"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_typeName"))}, - Core.Field { - Core.fieldName = (Core.Name "fields"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_fields"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.Record"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.core.term"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "union"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "inj"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "field"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionField = (Core.Name "field")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionField = (Core.Name "term")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.fromList"))), - Core.applicationArgument = (Core.TermList [ - Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "annotated"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "annotated"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.annotatedTerm")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "application"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "application"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.application")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "either"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "either"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "function"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "function"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.function")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "let"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "let"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.let")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "list"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeList")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "literal"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.literal")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "map"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "map"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "maybe"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "maybe"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeMaybe")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "pair"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "pair"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodePair")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "record"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.record")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "set"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "set"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeSet")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeApplication"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "typeApplication"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.typeApplicationTerm")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeLambda"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "typeLambda"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.typeLambda")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "union"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "union"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.injection")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unit"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "variable"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "variable"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "wrap"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Term"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wrap"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.wrappedTerm")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))))])})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maybes.maybe"))), - Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.cat"))), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.core.Name")))), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "f"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "f")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.lookup"))), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.Term"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.core.type"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "union"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "inj"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "field"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionField = (Core.Name "field")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionField = (Core.Name "term")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.fromList"))), - Core.applicationArgument = (Core.TermList [ - Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "annotated"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "annotated"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.annotatedType")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "application"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "application"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.applicationType")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "either"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "either"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.eitherType")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "forall"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "forall"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.forallType")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "function"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "function"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.functionType")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "list"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "list"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.type")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "literal"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.literalType")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "map"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "map"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.mapType")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "maybe"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "maybe"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.type")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "pair"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "pair"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.pairType")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "record"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeList")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.fieldType"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "set"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "set"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.type")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "union"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "union"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeList")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.fieldType"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unit"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unit"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "variable"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "variable"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.name")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "void"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "void"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "wrap"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.core.Type"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "wrap"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.type")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))))])})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maybes.maybe"))), - Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.cat"))), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.core.Name")))), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "f"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "f")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.lookup"))), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.Type"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.core.typeApplicationTerm"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "body"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_body"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "type"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_type"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.TypeApplicationTerm"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_body"))}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_type"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.TypeApplicationTerm"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.core.typeLambda"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "parameter"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_parameter"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "body"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_body"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.TypeLambda"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "parameter"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_parameter"))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_body"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.TypeLambda"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.core.typeScheme"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "variables"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeList")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_variables"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "type"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_type"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "constraints"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeMaybe")), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.typeVariableMetadata"))}))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_constraints"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.TypeScheme"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "variables"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_variables"))}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_type"))}, - Core.Field { - Core.fieldName = (Core.Name "constraints"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_constraints"))}]}))))})))}))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.TypeScheme"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.core.typeVariableMetadata"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "classes"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeSet")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_classes"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.TypeVariableMetadata"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "classes"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_classes"))}]}))))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.TypeVariableMetadata"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.core.wrappedTerm"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "typeName"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_typeName"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "body"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_body"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_typeName"))}, - Core.Field { - Core.fieldName = (Core.Name "body"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_body"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.WrappedTerm"))}))}))})), - Core.typeSchemeConstraints = Nothing}))}))], - Module.moduleTermDependencies = [ - Module.Namespace "hydra.extract.helpers", - (Module.Namespace "hydra.lexical"), - (Module.Namespace "hydra.rewriting"), - (Module.Namespace "hydra.decode.core")], - Module.moduleTypeDependencies = [ - Module.Namespace "hydra.core", - (Module.Namespace "hydra.util")], - Module.moduleDescription = (Just "Term decoders for hydra.core")} diff --git a/src/gen-main/haskell/Hydra/Sources/Decode/Error/Checking.hs b/src/gen-main/haskell/Hydra/Sources/Decode/Error/Checking.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Sources/Decode/Error/Checking.hs +++ /dev/null @@ -1,1409 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Source module for hydra.decode.error.checking - -module Hydra.Sources.Decode.Error.Checking where - -import qualified Hydra.Core as Core -import qualified Hydra.Module as Module -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -module_ :: Module.Module -module_ = - Module.Module { - Module.moduleNamespace = (Module.Namespace "hydra.decode.error.checking"), - Module.moduleDefinitions = [ - Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.checking.checkingError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "union"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "inj"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "field"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionField = (Core.Name "field")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionField = (Core.Name "term")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.fromList"))), - Core.applicationArgument = (Core.TermList [ - Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "incorrectUnification"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "incorrectUnification"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.checking.incorrectUnificationError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "notAForallType"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "notAForallType"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.checking.notAForallTypeError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "notAFunctionType"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "notAFunctionType"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.checking.notAFunctionTypeError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeArityMismatch"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "typeArityMismatch"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.checking.typeArityMismatchError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeMismatch"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "typeMismatch"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.checking.typeMismatchError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unboundTypeVariables"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unboundTypeVariables"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.checking.unboundTypeVariablesError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unequalTypes"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unequalTypes"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.checking.unequalTypesError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unsupportedTermVariant"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unsupportedTermVariant"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.checking.unsupportedTermVariantError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "untypedLambda"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "untypedLambda"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.checking.untypedLambdaError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "untypedLetBinding"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "untypedLetBinding"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.checking.untypedLetBindingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))))])})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maybes.maybe"))), - Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.cat"))), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.core.Name")))), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "f"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "f")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.lookup"))), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.checking.CheckingError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))}), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.checking.incorrectUnificationError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "substitution"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.typing.typeSubst"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_substitution"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.IncorrectUnificationError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "substitution"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_substitution"))}]}))))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.checking.IncorrectUnificationError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.checking.notAForallTypeError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "type"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_type"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "typeArguments"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeList")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_typeArguments"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.NotAForallTypeError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_type"))}, - Core.Field { - Core.fieldName = (Core.Name "typeArguments"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_typeArguments"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.checking.NotAForallTypeError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.checking.notAFunctionTypeError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "type"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_type"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.NotAFunctionTypeError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_type"))}]}))))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.checking.NotAFunctionTypeError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.checking.typeArityMismatchError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "type"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_type"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "expectedArity"))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 value"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "int32"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "i"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i"))))})))}]}))))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))})))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_expectedArity"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "actualArity"))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "integer"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 value"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "int32"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "i"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i"))))})))}]}))))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))})))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_actualArity"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "typeArguments"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeList")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_typeArguments"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.TypeArityMismatchError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_type"))}, - Core.Field { - Core.fieldName = (Core.Name "expectedArity"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_expectedArity"))}, - Core.Field { - Core.fieldName = (Core.Name "actualArity"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_actualArity"))}, - Core.Field { - Core.fieldName = (Core.Name "typeArguments"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_typeArguments"))}]}))))})))}))})))}))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.checking.TypeArityMismatchError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.checking.typeMismatchError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "expectedType"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_expectedType"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "actualType"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_actualType"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.TypeMismatchError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "expectedType"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_expectedType"))}, - Core.Field { - Core.fieldName = (Core.Name "actualType"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_actualType"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.checking.TypeMismatchError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.checking.unboundTypeVariablesError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "variables"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeSet")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_variables"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "type"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_type"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.UnboundTypeVariablesError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "variables"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_variables"))}, - Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_type"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.checking.UnboundTypeVariablesError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.checking.unequalTypesError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "types"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeList")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_types"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "description"))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "s"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))})))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_description"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.UnequalTypesError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "types"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_types"))}, - Core.Field { - Core.fieldName = (Core.Name "description"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_description"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.checking.UnequalTypesError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.checking.unsupportedTermVariantError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "termVariant"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.variants.termVariant"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_termVariant"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.UnsupportedTermVariantError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "termVariant"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_termVariant"))}]}))))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.checking.UnsupportedTermVariantError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.checking.untypedLambdaError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.UntypedLambdaError"), - Core.recordFields = []}))))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.checking.UntypedLambdaError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.checking.untypedLetBindingError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "binding"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.binding"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_binding"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.checking.UntypedLetBindingError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "binding"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_binding"))}]}))))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.checking.UntypedLetBindingError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))}))], - Module.moduleTermDependencies = [ - Module.Namespace "hydra.extract.helpers", - (Module.Namespace "hydra.lexical"), - (Module.Namespace "hydra.rewriting"), - (Module.Namespace "hydra.decode.core"), - (Module.Namespace "hydra.decode.typing"), - (Module.Namespace "hydra.decode.variants")], - Module.moduleTypeDependencies = [ - Module.Namespace "hydra.error.checking", - (Module.Namespace "hydra.util")], - Module.moduleDescription = (Just "Term decoders for hydra.error.checking")} diff --git a/src/gen-main/haskell/Hydra/Sources/Decode/Error/Core.hs b/src/gen-main/haskell/Hydra/Sources/Decode/Error/Core.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Sources/Decode/Error/Core.hs +++ /dev/null @@ -1,4613 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Source module for hydra.decode.error.core - -module Hydra.Sources.Decode.Error.Core where - -import qualified Hydra.Core as Core -import qualified Hydra.Module as Module -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -module_ :: Module.Module -module_ = - Module.Module { - Module.moduleNamespace = (Module.Namespace "hydra.decode.error.core"), - Module.moduleDefinitions = [ - Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.core.duplicateBindingError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_name"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.DuplicateBindingError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.DuplicateBindingError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))}), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.core.duplicateFieldError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_name"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.DuplicateFieldError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.DuplicateFieldError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.core.undefinedFieldError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "fieldName"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_fieldName"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "typeName"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_typeName"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedFieldError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "fieldName"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_fieldName"))}, - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_typeName"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.UndefinedFieldError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.core.unexpectedTermVariantError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "expectedVariant"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.variants.termVariant"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_expectedVariant"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "actualTerm"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_actualTerm"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UnexpectedTermVariantError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "expectedVariant"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_expectedVariant"))}, - Core.Field { - Core.fieldName = (Core.Name "actualTerm"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_actualTerm"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.UnexpectedTermVariantError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.core.unexpectedTypeVariantError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "expectedVariant"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.variants.typeVariant"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_expectedVariant"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "actualType"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_actualType"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UnexpectedTypeVariantError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "expectedVariant"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_expectedVariant"))}, - Core.Field { - Core.fieldName = (Core.Name "actualType"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_actualType"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.UnexpectedTypeVariantError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.core.constantConditionError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "value"))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected boolean literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "boolean"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "b"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "b"))))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))})))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_value"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.ConstantConditionError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}, - Core.Field { - Core.fieldName = (Core.Name "value"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_value"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.ConstantConditionError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.core.emptyCaseStatementError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "typeName"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_typeName"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.EmptyCaseStatementError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}, - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_typeName"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.EmptyCaseStatementError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.core.emptyLetBindingsError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.EmptyLetBindingsError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}]}))))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.EmptyLetBindingsError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.core.emptyTermAnnotationError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.EmptyTermAnnotationError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}]}))))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.EmptyTermAnnotationError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.core.emptyTypeNameInTermError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.EmptyTypeNameInTermError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}]}))))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.EmptyTypeNameInTermError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.core.invalidLambdaParameterNameError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_name"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.InvalidLambdaParameterNameError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.InvalidLambdaParameterNameError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.core.invalidLetBindingNameError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_name"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.InvalidLetBindingNameError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.InvalidLetBindingNameError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.core.invalidTypeLambdaParameterNameError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_name"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.InvalidTypeLambdaParameterNameError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.InvalidTypeLambdaParameterNameError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.core.nestedTermAnnotationError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.NestedTermAnnotationError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}]}))))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.NestedTermAnnotationError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.core.redundantWrapUnwrapError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "typeName"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_typeName"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.RedundantWrapUnwrapError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}, - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_typeName"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.RedundantWrapUnwrapError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.core.selfApplicationError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_name"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.SelfApplicationError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.SelfApplicationError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.core.termVariableShadowingError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_name"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.TermVariableShadowingError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.TermVariableShadowingError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.core.typeVariableShadowingInTypeLambdaError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_name"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.TypeVariableShadowingInTypeLambdaError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.TypeVariableShadowingInTypeLambdaError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.core.undefinedTermVariableError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_name"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedTermVariableError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.UndefinedTermVariableError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.core.undefinedTypeVariableInBindingTypeError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_name"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInBindingTypeError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.UndefinedTypeVariableInBindingTypeError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.core.undefinedTypeVariableInLambdaDomainError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_name"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInLambdaDomainError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.UndefinedTypeVariableInLambdaDomainError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.core.undefinedTypeVariableInTypeApplicationError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_name"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInTypeApplicationError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.UndefinedTypeVariableInTypeApplicationError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.core.unknownPrimitiveNameError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_name"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UnknownPrimitiveNameError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.UnknownPrimitiveNameError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.core.unnecessaryIdentityApplicationError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UnnecessaryIdentityApplicationError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}]}))))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.UnnecessaryIdentityApplicationError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.core.untypedTermVariableError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_name"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UntypedTermVariableError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.UntypedTermVariableError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.core.invalidTermError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "union"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "inj"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "field"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionField = (Core.Name "field")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionField = (Core.Name "term")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.fromList"))), - Core.applicationArgument = (Core.TermList [ - Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "constantCondition"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "constantCondition"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.constantConditionError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "duplicateBinding"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "duplicateBinding"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.duplicateBindingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "duplicateField"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "duplicateField"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.duplicateFieldError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "emptyCaseStatement"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "emptyCaseStatement"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.emptyCaseStatementError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "emptyLetBindings"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "emptyLetBindings"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.emptyLetBindingsError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "emptyTermAnnotation"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "emptyTermAnnotation"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.emptyTermAnnotationError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "emptyTypeNameInTerm"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "emptyTypeNameInTerm"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.emptyTypeNameInTermError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "invalidLambdaParameterName"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "invalidLambdaParameterName"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.invalidLambdaParameterNameError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "invalidLetBindingName"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "invalidLetBindingName"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.invalidLetBindingNameError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "invalidTypeLambdaParameterName"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "invalidTypeLambdaParameterName"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.invalidTypeLambdaParameterNameError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "nestedTermAnnotation"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "nestedTermAnnotation"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.nestedTermAnnotationError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "redundantWrapUnwrap"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "redundantWrapUnwrap"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.redundantWrapUnwrapError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "selfApplication"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "selfApplication"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.selfApplicationError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "termVariableShadowing"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "termVariableShadowing"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.termVariableShadowingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeVariableShadowingInTypeLambda"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "typeVariableShadowingInTypeLambda"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.typeVariableShadowingInTypeLambdaError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "undefinedTermVariable"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "undefinedTermVariable"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.undefinedTermVariableError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "undefinedTypeVariableInBindingType"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "undefinedTypeVariableInBindingType"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.undefinedTypeVariableInBindingTypeError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "undefinedTypeVariableInLambdaDomain"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "undefinedTypeVariableInLambdaDomain"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.undefinedTypeVariableInLambdaDomainError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "undefinedTypeVariableInTypeApplication"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "undefinedTypeVariableInTypeApplication"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.undefinedTypeVariableInTypeApplicationError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unknownPrimitiveName"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unknownPrimitiveName"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.unknownPrimitiveNameError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unnecessaryIdentityApplication"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unnecessaryIdentityApplication"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.unnecessaryIdentityApplicationError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "untypedTermVariable"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "untypedTermVariable"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.untypedTermVariableError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))))])})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maybes.maybe"))), - Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.cat"))), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.core.Name")))), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "f"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "f")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.lookup"))), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.InvalidTermError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.core.duplicateRecordTypeFieldNamesError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_name"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.DuplicateRecordTypeFieldNamesError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.DuplicateRecordTypeFieldNamesError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.core.duplicateUnionTypeFieldNamesError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_name"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.DuplicateUnionTypeFieldNamesError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.DuplicateUnionTypeFieldNamesError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.core.emptyRecordTypeError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.EmptyRecordTypeError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}]}))))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.EmptyRecordTypeError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.core.emptyTypeAnnotationError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.EmptyTypeAnnotationError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}]}))))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.EmptyTypeAnnotationError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.core.emptyUnionTypeError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.EmptyUnionTypeError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}]}))))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.EmptyUnionTypeError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.core.invalidForallParameterNameError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_name"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.InvalidForallParameterNameError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.InvalidForallParameterNameError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.core.invalidTypeSchemeVariableNameError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_name"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.InvalidTypeSchemeVariableNameError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.InvalidTypeSchemeVariableNameError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.core.nestedTypeAnnotationError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.NestedTypeAnnotationError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}]}))))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.NestedTypeAnnotationError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.core.nonComparableMapKeyTypeError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "keyType"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_keyType"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.NonComparableMapKeyTypeError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}, - Core.Field { - Core.fieldName = (Core.Name "keyType"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_keyType"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.NonComparableMapKeyTypeError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.core.nonComparableSetElementTypeError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "elementType"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_elementType"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.NonComparableSetElementTypeError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}, - Core.Field { - Core.fieldName = (Core.Name "elementType"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_elementType"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.NonComparableSetElementTypeError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.core.singleVariantUnionError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "fieldName"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_fieldName"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.SingleVariantUnionError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}, - Core.Field { - Core.fieldName = (Core.Name "fieldName"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_fieldName"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.SingleVariantUnionError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.core.typeVariableShadowingInForallError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_name"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.TypeVariableShadowingInForallError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.TypeVariableShadowingInForallError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.core.undefinedTypeVariableError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_name"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.UndefinedTypeVariableError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.core.voidInNonBottomPositionError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_location"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.core.VoidInNonBottomPositionError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "location"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}]}))))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.VoidInNonBottomPositionError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.core.invalidTypeError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "union"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "inj"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "field"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionField = (Core.Name "field")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionField = (Core.Name "term")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.fromList"))), - Core.applicationArgument = (Core.TermList [ - Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "duplicateRecordTypeFieldNames"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "duplicateRecordTypeFieldNames"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.duplicateRecordTypeFieldNamesError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "duplicateUnionTypeFieldNames"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "duplicateUnionTypeFieldNames"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.duplicateUnionTypeFieldNamesError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "emptyRecordType"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "emptyRecordType"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.emptyRecordTypeError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "emptyTypeAnnotation"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "emptyTypeAnnotation"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.emptyTypeAnnotationError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "emptyUnionType"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "emptyUnionType"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.emptyUnionTypeError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "invalidForallParameterName"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "invalidForallParameterName"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.invalidForallParameterNameError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "invalidTypeSchemeVariableName"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "invalidTypeSchemeVariableName"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.invalidTypeSchemeVariableNameError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "nestedTypeAnnotation"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "nestedTypeAnnotation"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.nestedTypeAnnotationError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "nonComparableMapKeyType"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "nonComparableMapKeyType"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.nonComparableMapKeyTypeError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "nonComparableSetElementType"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "nonComparableSetElementType"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.nonComparableSetElementTypeError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "singleVariantUnion"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "singleVariantUnion"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.singleVariantUnionError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeVariableShadowingInForall"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "typeVariableShadowingInForall"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.typeVariableShadowingInForallError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "undefinedTypeVariable"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "undefinedTypeVariable"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.undefinedTypeVariableError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "voidInNonBottomPosition"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "voidInNonBottomPosition"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.voidInNonBottomPositionError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))))])})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maybes.maybe"))), - Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.cat"))), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.core.Name")))), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "f"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "f")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.lookup"))), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.InvalidTypeError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))}))], - Module.moduleTermDependencies = [ - Module.Namespace "hydra.extract.helpers", - (Module.Namespace "hydra.lexical"), - (Module.Namespace "hydra.rewriting"), - (Module.Namespace "hydra.decode.paths"), - (Module.Namespace "hydra.decode.core"), - (Module.Namespace "hydra.decode.variants")], - Module.moduleTypeDependencies = [ - Module.Namespace "hydra.error.core", - (Module.Namespace "hydra.util")], - Module.moduleDescription = (Just "Term decoders for hydra.error.core")} diff --git a/src/gen-main/haskell/Hydra/Sources/Decode/Error/Packaging.hs b/src/gen-main/haskell/Hydra/Sources/Decode/Error/Packaging.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Sources/Decode/Error/Packaging.hs +++ /dev/null @@ -1,866 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Source module for hydra.decode.error.packaging - -module Hydra.Sources.Decode.Error.Packaging where - -import qualified Hydra.Core as Core -import qualified Hydra.Module as Module -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -module_ :: Module.Module -module_ = - Module.Module { - Module.moduleNamespace = (Module.Namespace "hydra.decode.error.packaging"), - Module.moduleDefinitions = [ - Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.packaging.conflictingModuleNamespaceError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "first"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.module.namespace"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_first"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "second"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.module.namespace"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_second"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.packaging.ConflictingModuleNamespaceError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "first"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_first"))}, - Core.Field { - Core.fieldName = (Core.Name "second"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_second"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.packaging.ConflictingModuleNamespaceError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))}), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.packaging.conflictingVariantNameError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "namespace"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.module.namespace"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_namespace"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "typeName"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_typeName"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "variantName"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_variantName"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "conflictingName"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_conflictingName"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.packaging.ConflictingVariantNameError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "namespace"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_namespace"))}, - Core.Field { - Core.fieldName = (Core.Name "typeName"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_typeName"))}, - Core.Field { - Core.fieldName = (Core.Name "variantName"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_variantName"))}, - Core.Field { - Core.fieldName = (Core.Name "conflictingName"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_conflictingName"))}]}))))})))}))})))}))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.packaging.ConflictingVariantNameError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.packaging.definitionNotInModuleNamespaceError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "namespace"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.module.namespace"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_namespace"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_name"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.packaging.DefinitionNotInModuleNamespaceError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "namespace"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_namespace"))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.packaging.DefinitionNotInModuleNamespaceError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.packaging.duplicateDefinitionNameError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "namespace"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.module.namespace"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_namespace"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_name"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.packaging.DuplicateDefinitionNameError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "namespace"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_namespace"))}, - Core.Field { - Core.fieldName = (Core.Name "name"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.packaging.DuplicateDefinitionNameError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.packaging.duplicateModuleNamespaceError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "namespace"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.module.namespace"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_namespace"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.error.packaging.DuplicateModuleNamespaceError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "namespace"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_namespace"))}]}))))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.packaging.DuplicateModuleNamespaceError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.packaging.invalidModuleError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "union"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "inj"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "field"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionField = (Core.Name "field")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionField = (Core.Name "term")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.fromList"))), - Core.applicationArgument = (Core.TermList [ - Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "conflictingVariantName"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidModuleError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "conflictingVariantName"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.packaging.conflictingVariantNameError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "definitionNotInModuleNamespace"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidModuleError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "definitionNotInModuleNamespace"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.packaging.definitionNotInModuleNamespaceError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "duplicateDefinitionName"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidModuleError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "duplicateDefinitionName"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.packaging.duplicateDefinitionNameError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))))])})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maybes.maybe"))), - Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.cat"))), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.core.Name")))), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "f"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "f")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.lookup"))), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.packaging.InvalidModuleError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.error.packaging.invalidPackageError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "union"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "inj"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "field"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionField = (Core.Name "field")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionField = (Core.Name "term")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.fromList"))), - Core.applicationArgument = (Core.TermList [ - Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "conflictingModuleNamespace"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidPackageError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "conflictingModuleNamespace"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.packaging.conflictingModuleNamespaceError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "duplicateModuleNamespace"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidPackageError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "duplicateModuleNamespace"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.packaging.duplicateModuleNamespaceError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "invalidModule"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidPackageError"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "invalidModule"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.packaging.invalidModuleError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))))])})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maybes.maybe"))), - Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.cat"))), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.core.Name")))), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "f"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "f")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.lookup"))), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.packaging.InvalidPackageError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))}))], - Module.moduleTermDependencies = [ - Module.Namespace "hydra.extract.helpers", - (Module.Namespace "hydra.lexical"), - (Module.Namespace "hydra.rewriting"), - (Module.Namespace "hydra.decode.core"), - (Module.Namespace "hydra.decode.module")], - Module.moduleTypeDependencies = [ - Module.Namespace "hydra.error.packaging", - (Module.Namespace "hydra.util")], - Module.moduleDescription = (Just "Term decoders for hydra.error.packaging")} diff --git a/src/gen-main/haskell/Hydra/Sources/Decode/Errors.hs b/src/gen-main/haskell/Hydra/Sources/Decode/Errors.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Sources/Decode/Errors.hs +++ /dev/null @@ -1,769 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Source module for hydra.decode.errors - -module Hydra.Sources.Decode.Errors where - -import qualified Hydra.Core as Core -import qualified Hydra.Module as Module -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -module_ :: Module.Module -module_ = - Module.Module { - Module.moduleNamespace = (Module.Namespace "hydra.decode.errors"), - Module.moduleDefinitions = [ - Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.errors.decodingError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected wrapped type"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "wrap"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "wrappedTerm"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "b"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "s"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.projectionField = (Core.Name "body")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "wrappedTerm"))}))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))}), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.errors.error"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "union"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "inj"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "field"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionField = (Core.Name "field")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionField = (Core.Name "term")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.fromList"))), - Core.applicationArgument = (Core.TermList [ - Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "checking"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.Error"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "checking"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.checking.checkingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "decoding"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.Error"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "decoding"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.errors.decodingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "duplicateBinding"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.Error"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "duplicateBinding"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.duplicateBindingError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "duplicateField"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.Error"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "duplicateField"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.duplicateFieldError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "other"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.Error"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "other"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.errors.otherError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "undefinedField"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.Error"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "undefinedField"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.undefinedFieldError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "undefinedTermVariable"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.Error"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "undefinedTermVariable"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.undefinedTermVariableError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "untypedTermVariable"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.Error"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "untypedTermVariable"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.untypedTermVariableError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unexpectedTermVariant"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.Error"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unexpectedTermVariant"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.unexpectedTermVariantError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unexpectedTypeVariant"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.Error"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unexpectedTypeVariant"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.unexpectedTypeVariantError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unification"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.errors.Error"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "unification"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.errors.unificationError")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))))])})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maybes.maybe"))), - Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.cat"))), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.core.Name")))), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "f"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "f")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.lookup"))), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.errors.Error"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.errors.otherError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected wrapped type"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "wrap"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "wrappedTerm"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "b"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.OtherError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "s"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.projectionField = (Core.Name "body")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "wrappedTerm"))}))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.errors.OtherError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.errors.unificationError"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "leftType"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_leftType"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "rightType"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_rightType"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "message"))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "s"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))})))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_message"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.errors.UnificationError"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "leftType"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_leftType"))}, - Core.Field { - Core.fieldName = (Core.Name "rightType"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_rightType"))}, - Core.Field { - Core.fieldName = (Core.Name "message"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_message"))}]}))))})))}))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.errors.UnificationError"))}))}))})), - Core.typeSchemeConstraints = Nothing}))}))], - Module.moduleTermDependencies = [ - Module.Namespace "hydra.extract.helpers", - (Module.Namespace "hydra.lexical"), - (Module.Namespace "hydra.rewriting"), - (Module.Namespace "hydra.decode.context"), - (Module.Namespace "hydra.decode.core"), - (Module.Namespace "hydra.decode.error.checking"), - (Module.Namespace "hydra.decode.error.core"), - (Module.Namespace "hydra.decode.typing"), - (Module.Namespace "hydra.decode.variants")], - Module.moduleTypeDependencies = [ - Module.Namespace "hydra.errors", - (Module.Namespace "hydra.util")], - Module.moduleDescription = (Just "Term decoders for hydra.errors")} diff --git a/src/gen-main/haskell/Hydra/Sources/Decode/Json/Model.hs b/src/gen-main/haskell/Hydra/Sources/Decode/Json/Model.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Sources/Decode/Json/Model.hs +++ /dev/null @@ -1,475 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Source module for hydra.decode.json.model - -module Hydra.Sources.Decode.Json.Model where - -import qualified Hydra.Core as Core -import qualified Hydra.Module as Module -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -module_ :: Module.Module -module_ = - Module.Module { - Module.moduleNamespace = (Module.Namespace "hydra.decode.json.model"), - Module.moduleDefinitions = [ - Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.json.model.value"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "union"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "inj"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "field"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionField = (Core.Name "field")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionField = (Core.Name "term")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.fromList"))), - Core.applicationArgument = (Core.TermList [ - Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "array"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.json.model.Value"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "array"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeList")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.json.model.value"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "boolean"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.json.model.Value"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "boolean"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected boolean literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "boolean"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "b"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "b"))))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "null"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.json.model.Value"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "null"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeUnit")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "number"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.json.model.Value"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "number"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected bigfloat literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "float"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.FloatValue"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected bigfloat value"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "bigfloat"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "f"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "f"))))})))}]}))))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "object"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.json.model.Value"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "object"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeMap")), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "s"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))})))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.json.model.value"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "string"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.json.model.Value"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "s"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))))])})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maybes.maybe"))), - Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.cat"))), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.core.Name")))), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "f"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "f")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.lookup"))), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.json.model.Value"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})], - Module.moduleTermDependencies = [ - Module.Namespace "hydra.extract.helpers", - (Module.Namespace "hydra.lexical"), - (Module.Namespace "hydra.rewriting"), - (Module.Namespace "hydra.decode.core")], - Module.moduleTypeDependencies = [ - Module.Namespace "hydra.json.model", - (Module.Namespace "hydra.util")], - Module.moduleDescription = (Just "Term decoders for hydra.json.model")} diff --git a/src/gen-main/haskell/Hydra/Sources/Decode/Module.hs b/src/gen-main/haskell/Hydra/Sources/Decode/Module.hs deleted file mode 100644 --- a/src/gen-main/haskell/Hydra/Sources/Decode/Module.hs +++ /dev/null @@ -1,1098 +0,0 @@ --- Note: this is an automatically generated file. Do not edit. - --- | Source module for hydra.decode.module - -module Hydra.Sources.Decode.Module where - -import qualified Hydra.Core as Core -import qualified Hydra.Module as Module -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) -import qualified Data.ByteString as B -import qualified Data.Int as I -import qualified Data.List as L -import qualified Data.Map as M -import qualified Data.Set as S - -module_ :: Module.Module -module_ = - Module.Module { - Module.moduleNamespace = (Module.Namespace "hydra.decode.module"), - Module.moduleDefinitions = [ - Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.module.definition"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "union"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "inj"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "field"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Injection"), - Core.projectionField = (Core.Name "field")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fname"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionField = (Core.Name "name")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "fterm"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.Field"), - Core.projectionField = (Core.Name "term")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})), - Core.bindingType = Nothing}, - Core.Binding { - Core.bindingName = (Core.Name "variantMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.fromList"))), - Core.applicationArgument = (Core.TermList [ - Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "term"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.module.Definition"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "term"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.module.termDefinition")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))), - (Core.TermPair (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "type"))}), (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "input"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "t"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermUnion (Core.Injection { - Core.injectionTypeName = (Core.Name "hydra.module.Definition"), - Core.injectionField = Core.Field { - Core.fieldName = (Core.Name "type"), - Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.module.typeDefinition")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))))])})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maybes.maybe"))), - Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.cat"))), - Core.applicationArgument = (Core.TermList [ - Core.TermLiteral (Core.LiteralString "no such field "), - (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationWrap (Core.Name "hydra.core.Name")))), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "f"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "f")), - Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.maps.lookup"))), - Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.module.Definition"))}))}))})), - Core.typeSchemeConstraints = Nothing}))}), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.module.fileExtension"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected wrapped type"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "wrap"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "wrappedTerm"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.map"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "b"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.module.FileExtension"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "s"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection { - Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"), - Core.projectionField = (Core.Name "body")})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "wrappedTerm"))}))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.module.FileExtension"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.module.module"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected record"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "record"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "record"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermLet (Core.Let { - Core.letBindings = [ - Core.Binding { - Core.bindingName = (Core.Name "fieldMap"), - Core.bindingTerm = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.toFieldMap")), - Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})), - Core.bindingType = Nothing}], - Core.letBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "namespace"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.module.namespace"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_namespace"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "definitions"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeList")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.module.definition"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_definitions"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "termDependencies"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeList")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.module.namespace"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_termDependencies"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "typeDependencies"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeList")), - Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.module.namespace"))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_typeDependencies"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.bind"))), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.requireField")), - Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "description"))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.helpers.decodeMaybe")), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Term"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "literal"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "v"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement { - Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"), - Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))), - Core.caseStatementCases = [ - Core.Field { - Core.fieldName = (Core.Name "string"), - Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "s"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))})))}))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "field_description"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record { - Core.recordTypeName = (Core.Name "hydra.module.Module"), - Core.recordFields = [ - Core.Field { - Core.fieldName = (Core.Name "namespace"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_namespace"))}, - Core.Field { - Core.fieldName = (Core.Name "definitions"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_definitions"))}, - Core.Field { - Core.fieldName = (Core.Name "termDependencies"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_termDependencies"))}, - Core.Field { - Core.fieldName = (Core.Name "typeDependencies"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_typeDependencies"))}, - Core.Field { - Core.fieldName = (Core.Name "description"), - Core.fieldTerm = (Core.TermVariable (Core.Name "field_description"))}]}))))})))}))})))}))})))}))})))}))})))}))}))})))}]})))), - Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))})))})), - Core.applicationArgument = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lexical.stripAndDereferenceTermEither")), - Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})), - Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))})))}))), - Module.termDefinitionType = (Just (Core.TypeScheme { - Core.typeSchemeVariables = [], - Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")), - Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType { - Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")), - Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType { - Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")), - Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.module.Module"))}))}))})), - Core.typeSchemeConstraints = Nothing}))})), - (Module.DefinitionTerm (Module.TermDefinition { - Module.termDefinitionName = (Core.Name "hydra.decode.module.namespace"), - Module.termDefinitionTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "cx"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "raw"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermApplication (Core.Application { - Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.eithers.either"))), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "err"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm { - Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"), - Core.wrappedTermBody = (Core.TermVariable (Core.Name "err"))}))))})))})), - Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda { - Core.lambdaParameter = (Core.Name "stripped"), - Core.lambdaDomain = Nothing, - Core.lambdaBody = (Core.TermApplication (Core.Application { - Core.applicatio