hydra-0.14.0: src/gen-main/haskell/Hydra/Encode/Testing.hs

-- 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))}]})