hydra-0.14.0: src/gen-test/haskell/Hydra/Test/EtaExpansion.hs

-- Note: this is an automatically generated file. Do not edit.

-- | Test cases for eta expansion of terms

module Hydra.Test.EtaExpansion where

import qualified Hydra.Core as Core
import qualified Hydra.Test.TestTypes as TestTypes
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

-- | Test cases for eta expansion of terms
allTests :: Testing.TestGroup
allTests =
    Testing.TestGroup {
      Testing.testGroupName = "eta expansion",
      Testing.testGroupDescription = Nothing,
      Testing.testGroupSubgroups = [
        Testing.TestGroup {
          Testing.testGroupName = "Partial application of primitives",
          Testing.testGroupDescription = Nothing,
          Testing.testGroupSubgroups = [
            Testing.TestGroup {
              Testing.testGroupName = "Bare primitives are not expanded",
              Testing.testGroupDescription = Nothing,
              Testing.testGroupSubgroups = [],
              Testing.testGroupCases = [
                Testing.TestCaseWithMetadata {
                  Testing.testCaseWithMetadataName = "unary primitive",
                  Testing.testCaseWithMetadataCase = (Testing.TestCaseEtaExpansion (Testing.EtaExpansionTestCase {
                    Testing.etaExpansionTestCaseInput = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.toLower"))),
                    Testing.etaExpansionTestCaseOutput = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.toLower")))})),
                  Testing.testCaseWithMetadataDescription = Nothing,
                  Testing.testCaseWithMetadataTags = []},
                Testing.TestCaseWithMetadata {
                  Testing.testCaseWithMetadataName = "binary primitive",
                  Testing.testCaseWithMetadataCase = (Testing.TestCaseEtaExpansion (Testing.EtaExpansionTestCase {
                    Testing.etaExpansionTestCaseInput = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.splitOn"))),
                    Testing.etaExpansionTestCaseOutput = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.splitOn")))})),
                  Testing.testCaseWithMetadataDescription = Nothing,
                  Testing.testCaseWithMetadataTags = []}]},
            Testing.TestGroup {
              Testing.testGroupName = "Partially applied primitives expand with lambdas",
              Testing.testGroupDescription = Nothing,
              Testing.testGroupSubgroups = [],
              Testing.testGroupCases = [
                Testing.TestCaseWithMetadata {
                  Testing.testCaseWithMetadataName = "binary primitive with one argument",
                  Testing.testCaseWithMetadataCase = (Testing.TestCaseEtaExpansion (Testing.EtaExpansionTestCase {
                    Testing.etaExpansionTestCaseInput = (Core.TermApplication (Core.Application {
                      Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.splitOn"))),
                      Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "foo"))})),
                    Testing.etaExpansionTestCaseOutput = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                      Core.lambdaParameter = (Core.Name "v1"),
                      Core.lambdaDomain = Nothing,
                      Core.lambdaBody = (Core.TermApplication (Core.Application {
                        Core.applicationFunction = (Core.TermApplication (Core.Application {
                          Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.splitOn"))),
                          Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "foo"))})),
                        Core.applicationArgument = (Core.TermVariable (Core.Name "v1"))}))})))})),
                  Testing.testCaseWithMetadataDescription = Nothing,
                  Testing.testCaseWithMetadataTags = []},
                Testing.TestCaseWithMetadata {
                  Testing.testCaseWithMetadataName = "ternary primitive with one argument",
                  Testing.testCaseWithMetadataCase = (Testing.TestCaseEtaExpansion (Testing.EtaExpansionTestCase {
                    Testing.etaExpansionTestCaseInput = (Core.TermApplication (Core.Application {
                      Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.lists.foldl"))),
                      Core.applicationArgument = (Core.TermVariable (Core.Name "f"))})),
                    Testing.etaExpansionTestCaseOutput = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                      Core.lambdaParameter = (Core.Name "v1"),
                      Core.lambdaDomain = Nothing,
                      Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                        Core.lambdaParameter = (Core.Name "v2"),
                        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.lists.foldl"))),
                              Core.applicationArgument = (Core.TermVariable (Core.Name "f"))})),
                            Core.applicationArgument = (Core.TermVariable (Core.Name "v1"))})),
                          Core.applicationArgument = (Core.TermVariable (Core.Name "v2"))}))})))})))})),
                  Testing.testCaseWithMetadataDescription = Nothing,
                  Testing.testCaseWithMetadataTags = []}]},
            Testing.TestGroup {
              Testing.testGroupName = "Fully applied primitives are not expanded",
              Testing.testGroupDescription = Nothing,
              Testing.testGroupSubgroups = [],
              Testing.testGroupCases = [
                Testing.TestCaseWithMetadata {
                  Testing.testCaseWithMetadataName = "unary primitive",
                  Testing.testCaseWithMetadataCase = (Testing.TestCaseEtaExpansion (Testing.EtaExpansionTestCase {
                    Testing.etaExpansionTestCaseInput = (Core.TermApplication (Core.Application {
                      Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.toLower"))),
                      Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "FOO"))})),
                    Testing.etaExpansionTestCaseOutput = (Core.TermApplication (Core.Application {
                      Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.toLower"))),
                      Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "FOO"))}))})),
                  Testing.testCaseWithMetadataDescription = Nothing,
                  Testing.testCaseWithMetadataTags = []},
                Testing.TestCaseWithMetadata {
                  Testing.testCaseWithMetadataName = "binary primitive",
                  Testing.testCaseWithMetadataCase = (Testing.TestCaseEtaExpansion (Testing.EtaExpansionTestCase {
                    Testing.etaExpansionTestCaseInput = (Core.TermApplication (Core.Application {
                      Core.applicationFunction = (Core.TermApplication (Core.Application {
                        Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.splitOn"))),
                        Core.applicationArgument = (Core.TermLiteral (Core.LiteralString ","))})),
                      Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "a,b,c"))})),
                    Testing.etaExpansionTestCaseOutput = (Core.TermApplication (Core.Application {
                      Core.applicationFunction = (Core.TermApplication (Core.Application {
                        Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.splitOn"))),
                        Core.applicationArgument = (Core.TermLiteral (Core.LiteralString ","))})),
                      Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "a,b,c"))}))})),
                  Testing.testCaseWithMetadataDescription = Nothing,
                  Testing.testCaseWithMetadataTags = []}]},
            Testing.TestGroup {
              Testing.testGroupName = "Record projections",
              Testing.testGroupDescription = Nothing,
              Testing.testGroupSubgroups = [
                Testing.TestGroup {
                  Testing.testGroupName = "Bare projections expand with a lambda",
                  Testing.testGroupDescription = Nothing,
                  Testing.testGroupSubgroups = [],
                  Testing.testGroupCases = [
                    Testing.TestCaseWithMetadata {
                      Testing.testCaseWithMetadataName = "projection without argument",
                      Testing.testCaseWithMetadataCase = (Testing.TestCaseEtaExpansion (Testing.EtaExpansionTestCase {
                        Testing.etaExpansionTestCaseInput = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection {
                          Core.projectionTypeName = TestTypes.testTypePersonName,
                          Core.projectionField = (Core.Name "firstName")})))),
                        Testing.etaExpansionTestCaseOutput = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                          Core.lambdaParameter = (Core.Name "v1"),
                          Core.lambdaDomain = Nothing,
                          Core.lambdaBody = (Core.TermApplication (Core.Application {
                            Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection {
                              Core.projectionTypeName = TestTypes.testTypePersonName,
                              Core.projectionField = (Core.Name "firstName")})))),
                            Core.applicationArgument = (Core.TermVariable (Core.Name "v1"))}))})))})),
                      Testing.testCaseWithMetadataDescription = Nothing,
                      Testing.testCaseWithMetadataTags = []}]},
                Testing.TestGroup {
                  Testing.testGroupName = "Applied projections are not expanded",
                  Testing.testGroupDescription = Nothing,
                  Testing.testGroupSubgroups = [],
                  Testing.testGroupCases = [
                    Testing.TestCaseWithMetadata {
                      Testing.testCaseWithMetadataName = "projection with argument",
                      Testing.testCaseWithMetadataCase = (Testing.TestCaseEtaExpansion (Testing.EtaExpansionTestCase {
                        Testing.etaExpansionTestCaseInput = (Core.TermApplication (Core.Application {
                          Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection {
                            Core.projectionTypeName = TestTypes.testTypePersonName,
                            Core.projectionField = (Core.Name "firstName")})))),
                          Core.applicationArgument = (Core.TermVariable (Core.Name "person"))})),
                        Testing.etaExpansionTestCaseOutput = (Core.TermApplication (Core.Application {
                          Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection {
                            Core.projectionTypeName = TestTypes.testTypePersonName,
                            Core.projectionField = (Core.Name "firstName")})))),
                          Core.applicationArgument = (Core.TermVariable (Core.Name "person"))}))})),
                      Testing.testCaseWithMetadataDescription = Nothing,
                      Testing.testCaseWithMetadataTags = []},
                    Testing.TestCaseWithMetadata {
                      Testing.testCaseWithMetadataName = "projection applied to a record",
                      Testing.testCaseWithMetadataCase = (Testing.TestCaseEtaExpansion (Testing.EtaExpansionTestCase {
                        Testing.etaExpansionTestCaseInput = (Core.TermApplication (Core.Application {
                          Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection {
                            Core.projectionTypeName = TestTypes.testTypePersonName,
                            Core.projectionField = (Core.Name "firstName")})))),
                          Core.applicationArgument = (Core.TermRecord (Core.Record {
                            Core.recordTypeName = TestTypes.testTypePersonName,
                            Core.recordFields = [
                              Core.Field {
                                Core.fieldName = (Core.Name "firstName"),
                                Core.fieldTerm = (Core.TermLiteral (Core.LiteralString "John"))},
                              Core.Field {
                                Core.fieldName = (Core.Name "lastName"),
                                Core.fieldTerm = (Core.TermLiteral (Core.LiteralString "Doe"))}]}))})),
                        Testing.etaExpansionTestCaseOutput = (Core.TermApplication (Core.Application {
                          Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection {
                            Core.projectionTypeName = TestTypes.testTypePersonName,
                            Core.projectionField = (Core.Name "firstName")})))),
                          Core.applicationArgument = (Core.TermRecord (Core.Record {
                            Core.recordTypeName = TestTypes.testTypePersonName,
                            Core.recordFields = [
                              Core.Field {
                                Core.fieldName = (Core.Name "firstName"),
                                Core.fieldTerm = (Core.TermLiteral (Core.LiteralString "John"))},
                              Core.Field {
                                Core.fieldName = (Core.Name "lastName"),
                                Core.fieldTerm = (Core.TermLiteral (Core.LiteralString "Doe"))}]}))}))})),
                      Testing.testCaseWithMetadataDescription = Nothing,
                      Testing.testCaseWithMetadataTags = []}]},
                Testing.TestGroup {
                  Testing.testGroupName = "Projections nested in other structures",
                  Testing.testGroupDescription = Nothing,
                  Testing.testGroupSubgroups = [],
                  Testing.testGroupCases = [
                    Testing.TestCaseWithMetadata {
                      Testing.testCaseWithMetadataName = "projection in a list",
                      Testing.testCaseWithMetadataCase = (Testing.TestCaseEtaExpansion (Testing.EtaExpansionTestCase {
                        Testing.etaExpansionTestCaseInput = (Core.TermList [
                          Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection {
                            Core.projectionTypeName = TestTypes.testTypePersonName,
                            Core.projectionField = (Core.Name "firstName")}))),
                          (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.toLower")))]),
                        Testing.etaExpansionTestCaseOutput = (Core.TermList [
                          Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                            Core.lambdaParameter = (Core.Name "v1"),
                            Core.lambdaDomain = Nothing,
                            Core.lambdaBody = (Core.TermApplication (Core.Application {
                              Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection {
                                Core.projectionTypeName = TestTypes.testTypePersonName,
                                Core.projectionField = (Core.Name "firstName")})))),
                              Core.applicationArgument = (Core.TermVariable (Core.Name "v1"))}))})),
                          (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.toLower")))])})),
                      Testing.testCaseWithMetadataDescription = Nothing,
                      Testing.testCaseWithMetadataTags = []},
                    Testing.TestCaseWithMetadata {
                      Testing.testCaseWithMetadataName = "projection in a tuple",
                      Testing.testCaseWithMetadataCase = (Testing.TestCaseEtaExpansion (Testing.EtaExpansionTestCase {
                        Testing.etaExpansionTestCaseInput = (Core.TermPair (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection {
                          Core.projectionTypeName = TestTypes.testTypePersonName,
                          Core.projectionField = (Core.Name "firstName")}))), (Core.TermLiteral (Core.LiteralString "default")))),
                        Testing.etaExpansionTestCaseOutput = (Core.TermPair (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                          Core.lambdaParameter = (Core.Name "v1"),
                          Core.lambdaDomain = Nothing,
                          Core.lambdaBody = (Core.TermApplication (Core.Application {
                            Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection {
                              Core.projectionTypeName = TestTypes.testTypePersonName,
                              Core.projectionField = (Core.Name "firstName")})))),
                            Core.applicationArgument = (Core.TermVariable (Core.Name "v1"))}))})), (Core.TermLiteral (Core.LiteralString "default"))))})),
                      Testing.testCaseWithMetadataDescription = Nothing,
                      Testing.testCaseWithMetadataTags = []},
                    Testing.TestCaseWithMetadata {
                      Testing.testCaseWithMetadataName = "projection in let binding",
                      Testing.testCaseWithMetadataCase = (Testing.TestCaseEtaExpansion (Testing.EtaExpansionTestCase {
                        Testing.etaExpansionTestCaseInput = (Core.TermLet (Core.Let {
                          Core.letBindings = [
                            Core.Binding {
                              Core.bindingName = (Core.Name "getter"),
                              Core.bindingTerm = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection {
                                Core.projectionTypeName = TestTypes.testTypePersonName,
                                Core.projectionField = (Core.Name "firstName")})))),
                              Core.bindingType = Nothing}],
                          Core.letBody = (Core.TermVariable (Core.Name "getter"))})),
                        Testing.etaExpansionTestCaseOutput = (Core.TermLet (Core.Let {
                          Core.letBindings = [
                            Core.Binding {
                              Core.bindingName = (Core.Name "getter"),
                              Core.bindingTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                                Core.lambdaParameter = (Core.Name "v1"),
                                Core.lambdaDomain = Nothing,
                                Core.lambdaBody = (Core.TermApplication (Core.Application {
                                  Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection {
                                    Core.projectionTypeName = TestTypes.testTypePersonName,
                                    Core.projectionField = (Core.Name "firstName")})))),
                                  Core.applicationArgument = (Core.TermVariable (Core.Name "v1"))}))}))),
                              Core.bindingType = Nothing}],
                          Core.letBody = (Core.TermVariable (Core.Name "getter"))}))})),
                      Testing.testCaseWithMetadataDescription = Nothing,
                      Testing.testCaseWithMetadataTags = []},
                    Testing.TestCaseWithMetadata {
                      Testing.testCaseWithMetadataName = "projection in lambda body",
                      Testing.testCaseWithMetadataCase = (Testing.TestCaseEtaExpansion (Testing.EtaExpansionTestCase {
                        Testing.etaExpansionTestCaseInput = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                          Core.lambdaParameter = (Core.Name "x"),
                          Core.lambdaDomain = Nothing,
                          Core.lambdaBody = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection {
                            Core.projectionTypeName = TestTypes.testTypePersonName,
                            Core.projectionField = (Core.Name "firstName")}))))}))),
                        Testing.etaExpansionTestCaseOutput = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                          Core.lambdaParameter = (Core.Name "x"),
                          Core.lambdaDomain = Nothing,
                          Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                            Core.lambdaParameter = (Core.Name "v1"),
                            Core.lambdaDomain = Nothing,
                            Core.lambdaBody = (Core.TermApplication (Core.Application {
                              Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection {
                                Core.projectionTypeName = TestTypes.testTypePersonName,
                                Core.projectionField = (Core.Name "firstName")})))),
                              Core.applicationArgument = (Core.TermVariable (Core.Name "v1"))}))})))})))})),
                      Testing.testCaseWithMetadataDescription = Nothing,
                      Testing.testCaseWithMetadataTags = []}]},
                Testing.TestGroup {
                  Testing.testGroupName = "Function-valued projections",
                  Testing.testGroupDescription = Nothing,
                  Testing.testGroupSubgroups = [],
                  Testing.testGroupCases = [
                    Testing.TestCaseWithMetadata {
                      Testing.testCaseWithMetadataName = "projection of function-valued field applied to arguments should not be expanded",
                      Testing.testCaseWithMetadataCase = (Testing.TestCaseEtaExpansion (Testing.EtaExpansionTestCase {
                        Testing.etaExpansionTestCaseInput = (Core.TermApplication (Core.Application {
                          Core.applicationFunction = (Core.TermApplication (Core.Application {
                            Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm {
                              Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm {
                                Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm {
                                  Core.typeApplicationTermBody = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection {
                                    Core.projectionTypeName = TestTypes.testTypeTripleName,
                                    Core.projectionField = (Core.Name "first")})))),
                                  Core.typeApplicationTermType = (Core.TypeFunction (Core.FunctionType {
                                    Core.functionTypeDomain = (Core.TypeLiteral Core.LiteralTypeString),
                                    Core.functionTypeCodomain = (Core.TypeLiteral Core.LiteralTypeString)}))})),
                                Core.typeApplicationTermType = (Core.TypeLiteral Core.LiteralTypeString)})),
                              Core.typeApplicationTermType = (Core.TypeLiteral Core.LiteralTypeString)})),
                            Core.applicationArgument = (Core.TermTypeApplication (Core.TypeApplicationTerm {
                              Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm {
                                Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm {
                                  Core.typeApplicationTermBody = (Core.TermRecord (Core.Record {
                                    Core.recordTypeName = TestTypes.testTypeTripleName,
                                    Core.recordFields = [
                                      Core.Field {
                                        Core.fieldName = (Core.Name "first"),
                                        Core.fieldTerm = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.toLower")))},
                                      Core.Field {
                                        Core.fieldName = (Core.Name "second"),
                                        Core.fieldTerm = (Core.TermLiteral (Core.LiteralString "middle"))},
                                      Core.Field {
                                        Core.fieldName = (Core.Name "third"),
                                        Core.fieldTerm = (Core.TermLiteral (Core.LiteralString "last"))}]})),
                                  Core.typeApplicationTermType = (Core.TypeFunction (Core.FunctionType {
                                    Core.functionTypeDomain = (Core.TypeLiteral Core.LiteralTypeString),
                                    Core.functionTypeCodomain = (Core.TypeLiteral Core.LiteralTypeString)}))})),
                                Core.typeApplicationTermType = (Core.TypeLiteral Core.LiteralTypeString)})),
                              Core.typeApplicationTermType = (Core.TypeLiteral Core.LiteralTypeString)}))})),
                          Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "DATA"))})),
                        Testing.etaExpansionTestCaseOutput = (Core.TermApplication (Core.Application {
                          Core.applicationFunction = (Core.TermApplication (Core.Application {
                            Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm {
                              Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm {
                                Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm {
                                  Core.typeApplicationTermBody = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection {
                                    Core.projectionTypeName = TestTypes.testTypeTripleName,
                                    Core.projectionField = (Core.Name "first")})))),
                                  Core.typeApplicationTermType = (Core.TypeFunction (Core.FunctionType {
                                    Core.functionTypeDomain = (Core.TypeLiteral Core.LiteralTypeString),
                                    Core.functionTypeCodomain = (Core.TypeLiteral Core.LiteralTypeString)}))})),
                                Core.typeApplicationTermType = (Core.TypeLiteral Core.LiteralTypeString)})),
                              Core.typeApplicationTermType = (Core.TypeLiteral Core.LiteralTypeString)})),
                            Core.applicationArgument = (Core.TermTypeApplication (Core.TypeApplicationTerm {
                              Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm {
                                Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm {
                                  Core.typeApplicationTermBody = (Core.TermRecord (Core.Record {
                                    Core.recordTypeName = TestTypes.testTypeTripleName,
                                    Core.recordFields = [
                                      Core.Field {
                                        Core.fieldName = (Core.Name "first"),
                                        Core.fieldTerm = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.toLower")))},
                                      Core.Field {
                                        Core.fieldName = (Core.Name "second"),
                                        Core.fieldTerm = (Core.TermLiteral (Core.LiteralString "middle"))},
                                      Core.Field {
                                        Core.fieldName = (Core.Name "third"),
                                        Core.fieldTerm = (Core.TermLiteral (Core.LiteralString "last"))}]})),
                                  Core.typeApplicationTermType = (Core.TypeFunction (Core.FunctionType {
                                    Core.functionTypeDomain = (Core.TypeLiteral Core.LiteralTypeString),
                                    Core.functionTypeCodomain = (Core.TypeLiteral Core.LiteralTypeString)}))})),
                                Core.typeApplicationTermType = (Core.TypeLiteral Core.LiteralTypeString)})),
                              Core.typeApplicationTermType = (Core.TypeLiteral Core.LiteralTypeString)}))})),
                          Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "DATA"))}))})),
                      Testing.testCaseWithMetadataDescription = Nothing,
                      Testing.testCaseWithMetadataTags = []}]}],
              Testing.testGroupCases = []}],
          Testing.testGroupCases = []},
        Testing.TestGroup {
          Testing.testGroupName = "Polymorphic terms (System F)",
          Testing.testGroupDescription = Nothing,
          Testing.testGroupSubgroups = [
            Testing.TestGroup {
              Testing.testGroupName = "Type lambdas in let bindings",
              Testing.testGroupDescription = Nothing,
              Testing.testGroupSubgroups = [],
              Testing.testGroupCases = [
                Testing.TestCaseWithMetadata {
                  Testing.testCaseWithMetadataName = "polymorphic identity function",
                  Testing.testCaseWithMetadataCase = (Testing.TestCaseEtaExpansion (Testing.EtaExpansionTestCase {
                    Testing.etaExpansionTestCaseInput = (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "id"),
                          Core.bindingTerm = (Core.TermTypeLambda (Core.TypeLambda {
                            Core.typeLambdaParameter = (Core.Name "a"),
                            Core.typeLambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                              Core.lambdaParameter = (Core.Name "x"),
                              Core.lambdaDomain = Nothing,
                              Core.lambdaBody = (Core.TermVariable (Core.Name "x"))})))})),
                          Core.bindingType = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [
                              Core.Name "a"],
                            Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
                              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "a")),
                              Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "a"))})),
                            Core.typeSchemeConstraints = Nothing}))}],
                      Core.letBody = (Core.TermVariable (Core.Name "id"))})),
                    Testing.etaExpansionTestCaseOutput = (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "id"),
                          Core.bindingTerm = (Core.TermTypeLambda (Core.TypeLambda {
                            Core.typeLambdaParameter = (Core.Name "a"),
                            Core.typeLambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                              Core.lambdaParameter = (Core.Name "x"),
                              Core.lambdaDomain = Nothing,
                              Core.lambdaBody = (Core.TermVariable (Core.Name "x"))})))})),
                          Core.bindingType = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [
                              Core.Name "a"],
                            Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
                              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "a")),
                              Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "a"))})),
                            Core.typeSchemeConstraints = Nothing}))}],
                      Core.letBody = (Core.TermVariable (Core.Name "id"))}))})),
                  Testing.testCaseWithMetadataDescription = Nothing,
                  Testing.testCaseWithMetadataTags = []},
                Testing.TestCaseWithMetadata {
                  Testing.testCaseWithMetadataName = "monomorphic partially applied primitive",
                  Testing.testCaseWithMetadataCase = (Testing.TestCaseEtaExpansion (Testing.EtaExpansionTestCase {
                    Testing.etaExpansionTestCaseInput = (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "partial"),
                          Core.bindingTerm = (Core.TermApplication (Core.Application {
                            Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.splitOn"))),
                            Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "foo"))})),
                          Core.bindingType = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [],
                            Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
                              Core.functionTypeDomain = (Core.TypeLiteral Core.LiteralTypeString),
                              Core.functionTypeCodomain = (Core.TypeList (Core.TypeLiteral Core.LiteralTypeString))})),
                            Core.typeSchemeConstraints = Nothing}))}],
                      Core.letBody = (Core.TermVariable (Core.Name "partial"))})),
                    Testing.etaExpansionTestCaseOutput = (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "partial"),
                          Core.bindingTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                            Core.lambdaParameter = (Core.Name "v1"),
                            Core.lambdaDomain = Nothing,
                            Core.lambdaBody = (Core.TermApplication (Core.Application {
                              Core.applicationFunction = (Core.TermApplication (Core.Application {
                                Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.splitOn"))),
                                Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "foo"))})),
                              Core.applicationArgument = (Core.TermVariable (Core.Name "v1"))}))}))),
                          Core.bindingType = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [],
                            Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
                              Core.functionTypeDomain = (Core.TypeLiteral Core.LiteralTypeString),
                              Core.functionTypeCodomain = (Core.TypeList (Core.TypeLiteral Core.LiteralTypeString))})),
                            Core.typeSchemeConstraints = Nothing}))}],
                      Core.letBody = (Core.TermVariable (Core.Name "partial"))}))})),
                  Testing.testCaseWithMetadataDescription = Nothing,
                  Testing.testCaseWithMetadataTags = []},
                Testing.TestCaseWithMetadata {
                  Testing.testCaseWithMetadataName = "monomorphic projection",
                  Testing.testCaseWithMetadataCase = (Testing.TestCaseEtaExpansion (Testing.EtaExpansionTestCase {
                    Testing.etaExpansionTestCaseInput = (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "getter"),
                          Core.bindingTerm = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection {
                            Core.projectionTypeName = TestTypes.testTypePersonName,
                            Core.projectionField = (Core.Name "firstName")})))),
                          Core.bindingType = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [],
                            Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
                              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "Person")),
                              Core.functionTypeCodomain = (Core.TypeLiteral Core.LiteralTypeString)})),
                            Core.typeSchemeConstraints = Nothing}))}],
                      Core.letBody = (Core.TermVariable (Core.Name "getter"))})),
                    Testing.etaExpansionTestCaseOutput = (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "getter"),
                          Core.bindingTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                            Core.lambdaParameter = (Core.Name "v1"),
                            Core.lambdaDomain = Nothing,
                            Core.lambdaBody = (Core.TermApplication (Core.Application {
                              Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection {
                                Core.projectionTypeName = TestTypes.testTypePersonName,
                                Core.projectionField = (Core.Name "firstName")})))),
                              Core.applicationArgument = (Core.TermVariable (Core.Name "v1"))}))}))),
                          Core.bindingType = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [],
                            Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
                              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "Person")),
                              Core.functionTypeCodomain = (Core.TypeLiteral Core.LiteralTypeString)})),
                            Core.typeSchemeConstraints = Nothing}))}],
                      Core.letBody = (Core.TermVariable (Core.Name "getter"))}))})),
                  Testing.testCaseWithMetadataDescription = Nothing,
                  Testing.testCaseWithMetadataTags = []}]},
            Testing.TestGroup {
              Testing.testGroupName = "Type applications of polymorphic bindings",
              Testing.testGroupDescription = Nothing,
              Testing.testGroupSubgroups = [],
              Testing.testGroupCases = [
                Testing.TestCaseWithMetadata {
                  Testing.testCaseWithMetadataName = "polymorphic variable with type application",
                  Testing.testCaseWithMetadataCase = (Testing.TestCaseEtaExpansion (Testing.EtaExpansionTestCase {
                    Testing.etaExpansionTestCaseInput = (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "id"),
                          Core.bindingTerm = (Core.TermTypeLambda (Core.TypeLambda {
                            Core.typeLambdaParameter = (Core.Name "a"),
                            Core.typeLambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                              Core.lambdaParameter = (Core.Name "x"),
                              Core.lambdaDomain = Nothing,
                              Core.lambdaBody = (Core.TermVariable (Core.Name "x"))})))})),
                          Core.bindingType = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [
                              Core.Name "a"],
                            Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
                              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "a")),
                              Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "a"))})),
                            Core.typeSchemeConstraints = Nothing}))}],
                      Core.letBody = (Core.TermTypeApplication (Core.TypeApplicationTerm {
                        Core.typeApplicationTermBody = (Core.TermVariable (Core.Name "id")),
                        Core.typeApplicationTermType = (Core.TypeLiteral Core.LiteralTypeString)}))})),
                    Testing.etaExpansionTestCaseOutput = (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "id"),
                          Core.bindingTerm = (Core.TermTypeLambda (Core.TypeLambda {
                            Core.typeLambdaParameter = (Core.Name "a"),
                            Core.typeLambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                              Core.lambdaParameter = (Core.Name "x"),
                              Core.lambdaDomain = Nothing,
                              Core.lambdaBody = (Core.TermVariable (Core.Name "x"))})))})),
                          Core.bindingType = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [
                              Core.Name "a"],
                            Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
                              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "a")),
                              Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "a"))})),
                            Core.typeSchemeConstraints = Nothing}))}],
                      Core.letBody = (Core.TermTypeApplication (Core.TypeApplicationTerm {
                        Core.typeApplicationTermBody = (Core.TermVariable (Core.Name "id")),
                        Core.typeApplicationTermType = (Core.TypeLiteral Core.LiteralTypeString)}))}))})),
                  Testing.testCaseWithMetadataDescription = Nothing,
                  Testing.testCaseWithMetadataTags = []},
                Testing.TestCaseWithMetadata {
                  Testing.testCaseWithMetadataName = "type application of identity applied to binary function with no arguments",
                  Testing.testCaseWithMetadataCase = (Testing.TestCaseEtaExpansion (Testing.EtaExpansionTestCase {
                    Testing.etaExpansionTestCaseInput = (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "id"),
                          Core.bindingTerm = (Core.TermTypeLambda (Core.TypeLambda {
                            Core.typeLambdaParameter = (Core.Name "a"),
                            Core.typeLambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                              Core.lambdaParameter = (Core.Name "x"),
                              Core.lambdaDomain = Nothing,
                              Core.lambdaBody = (Core.TermVariable (Core.Name "x"))})))})),
                          Core.bindingType = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [
                              Core.Name "a"],
                            Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
                              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "a")),
                              Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "a"))})),
                            Core.typeSchemeConstraints = Nothing}))}],
                      Core.letBody = (Core.TermApplication (Core.Application {
                        Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm {
                          Core.typeApplicationTermBody = (Core.TermVariable (Core.Name "id")),
                          Core.typeApplicationTermType = (Core.TypeFunction (Core.FunctionType {
                            Core.functionTypeDomain = (Core.TypeLiteral Core.LiteralTypeString),
                            Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
                              Core.functionTypeDomain = (Core.TypeLiteral Core.LiteralTypeString),
                              Core.functionTypeCodomain = (Core.TypeList (Core.TypeLiteral Core.LiteralTypeString))}))}))})),
                        Core.applicationArgument = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.splitOn")))}))})),
                    Testing.etaExpansionTestCaseOutput = (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "id"),
                          Core.bindingTerm = (Core.TermTypeLambda (Core.TypeLambda {
                            Core.typeLambdaParameter = (Core.Name "a"),
                            Core.typeLambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                              Core.lambdaParameter = (Core.Name "x"),
                              Core.lambdaDomain = Nothing,
                              Core.lambdaBody = (Core.TermVariable (Core.Name "x"))})))})),
                          Core.bindingType = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [
                              Core.Name "a"],
                            Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
                              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "a")),
                              Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "a"))})),
                            Core.typeSchemeConstraints = Nothing}))}],
                      Core.letBody = (Core.TermApplication (Core.Application {
                        Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm {
                          Core.typeApplicationTermBody = (Core.TermVariable (Core.Name "id")),
                          Core.typeApplicationTermType = (Core.TypeFunction (Core.FunctionType {
                            Core.functionTypeDomain = (Core.TypeLiteral Core.LiteralTypeString),
                            Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
                              Core.functionTypeDomain = (Core.TypeLiteral Core.LiteralTypeString),
                              Core.functionTypeCodomain = (Core.TypeList (Core.TypeLiteral Core.LiteralTypeString))}))}))})),
                        Core.applicationArgument = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.splitOn")))}))}))})),
                  Testing.testCaseWithMetadataDescription = Nothing,
                  Testing.testCaseWithMetadataTags = []},
                Testing.TestCaseWithMetadata {
                  Testing.testCaseWithMetadataName = "type application of identity applied to partially applied binary function",
                  Testing.testCaseWithMetadataCase = (Testing.TestCaseEtaExpansion (Testing.EtaExpansionTestCase {
                    Testing.etaExpansionTestCaseInput = (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "id"),
                          Core.bindingTerm = (Core.TermTypeLambda (Core.TypeLambda {
                            Core.typeLambdaParameter = (Core.Name "a"),
                            Core.typeLambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                              Core.lambdaParameter = (Core.Name "x"),
                              Core.lambdaDomain = Nothing,
                              Core.lambdaBody = (Core.TermVariable (Core.Name "x"))})))})),
                          Core.bindingType = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [
                              Core.Name "a"],
                            Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
                              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "a")),
                              Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "a"))})),
                            Core.typeSchemeConstraints = Nothing}))}],
                      Core.letBody = (Core.TermApplication (Core.Application {
                        Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm {
                          Core.typeApplicationTermBody = (Core.TermVariable (Core.Name "id")),
                          Core.typeApplicationTermType = (Core.TypeFunction (Core.FunctionType {
                            Core.functionTypeDomain = (Core.TypeLiteral Core.LiteralTypeString),
                            Core.functionTypeCodomain = (Core.TypeList (Core.TypeLiteral Core.LiteralTypeString))}))})),
                        Core.applicationArgument = (Core.TermApplication (Core.Application {
                          Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.splitOn"))),
                          Core.applicationArgument = (Core.TermLiteral (Core.LiteralString ","))}))}))})),
                    Testing.etaExpansionTestCaseOutput = (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "id"),
                          Core.bindingTerm = (Core.TermTypeLambda (Core.TypeLambda {
                            Core.typeLambdaParameter = (Core.Name "a"),
                            Core.typeLambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                              Core.lambdaParameter = (Core.Name "x"),
                              Core.lambdaDomain = Nothing,
                              Core.lambdaBody = (Core.TermVariable (Core.Name "x"))})))})),
                          Core.bindingType = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [
                              Core.Name "a"],
                            Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
                              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "a")),
                              Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "a"))})),
                            Core.typeSchemeConstraints = Nothing}))}],
                      Core.letBody = (Core.TermApplication (Core.Application {
                        Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm {
                          Core.typeApplicationTermBody = (Core.TermVariable (Core.Name "id")),
                          Core.typeApplicationTermType = (Core.TypeFunction (Core.FunctionType {
                            Core.functionTypeDomain = (Core.TypeLiteral Core.LiteralTypeString),
                            Core.functionTypeCodomain = (Core.TypeList (Core.TypeLiteral Core.LiteralTypeString))}))})),
                        Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                          Core.lambdaParameter = (Core.Name "v1"),
                          Core.lambdaDomain = Nothing,
                          Core.lambdaBody = (Core.TermApplication (Core.Application {
                            Core.applicationFunction = (Core.TermApplication (Core.Application {
                              Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.splitOn"))),
                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString ","))})),
                            Core.applicationArgument = (Core.TermVariable (Core.Name "v1"))}))})))}))}))})),
                  Testing.testCaseWithMetadataDescription = Nothing,
                  Testing.testCaseWithMetadataTags = []},
                Testing.TestCaseWithMetadata {
                  Testing.testCaseWithMetadataName = "type application of identity applied to fully applied binary function",
                  Testing.testCaseWithMetadataCase = (Testing.TestCaseEtaExpansion (Testing.EtaExpansionTestCase {
                    Testing.etaExpansionTestCaseInput = (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "id"),
                          Core.bindingTerm = (Core.TermTypeLambda (Core.TypeLambda {
                            Core.typeLambdaParameter = (Core.Name "a"),
                            Core.typeLambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                              Core.lambdaParameter = (Core.Name "x"),
                              Core.lambdaDomain = Nothing,
                              Core.lambdaBody = (Core.TermVariable (Core.Name "x"))})))})),
                          Core.bindingType = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [
                              Core.Name "a"],
                            Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
                              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "a")),
                              Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "a"))})),
                            Core.typeSchemeConstraints = Nothing}))}],
                      Core.letBody = (Core.TermApplication (Core.Application {
                        Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm {
                          Core.typeApplicationTermBody = (Core.TermVariable (Core.Name "id")),
                          Core.typeApplicationTermType = (Core.TypeList (Core.TypeLiteral Core.LiteralTypeString))})),
                        Core.applicationArgument = (Core.TermApplication (Core.Application {
                          Core.applicationFunction = (Core.TermApplication (Core.Application {
                            Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.splitOn"))),
                            Core.applicationArgument = (Core.TermLiteral (Core.LiteralString ","))})),
                          Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "foo,bar"))}))}))})),
                    Testing.etaExpansionTestCaseOutput = (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "id"),
                          Core.bindingTerm = (Core.TermTypeLambda (Core.TypeLambda {
                            Core.typeLambdaParameter = (Core.Name "a"),
                            Core.typeLambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                              Core.lambdaParameter = (Core.Name "x"),
                              Core.lambdaDomain = Nothing,
                              Core.lambdaBody = (Core.TermVariable (Core.Name "x"))})))})),
                          Core.bindingType = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [
                              Core.Name "a"],
                            Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
                              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "a")),
                              Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "a"))})),
                            Core.typeSchemeConstraints = Nothing}))}],
                      Core.letBody = (Core.TermApplication (Core.Application {
                        Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm {
                          Core.typeApplicationTermBody = (Core.TermVariable (Core.Name "id")),
                          Core.typeApplicationTermType = (Core.TypeList (Core.TypeLiteral Core.LiteralTypeString))})),
                        Core.applicationArgument = (Core.TermApplication (Core.Application {
                          Core.applicationFunction = (Core.TermApplication (Core.Application {
                            Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.splitOn"))),
                            Core.applicationArgument = (Core.TermLiteral (Core.LiteralString ","))})),
                          Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "foo,bar"))}))}))}))})),
                  Testing.testCaseWithMetadataDescription = Nothing,
                  Testing.testCaseWithMetadataTags = []},
                Testing.TestCaseWithMetadata {
                  Testing.testCaseWithMetadataName = "type application of identity applied to binary function, then applied to one argument",
                  Testing.testCaseWithMetadataCase = (Testing.TestCaseEtaExpansion (Testing.EtaExpansionTestCase {
                    Testing.etaExpansionTestCaseInput = (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "id"),
                          Core.bindingTerm = (Core.TermTypeLambda (Core.TypeLambda {
                            Core.typeLambdaParameter = (Core.Name "a"),
                            Core.typeLambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                              Core.lambdaParameter = (Core.Name "x"),
                              Core.lambdaDomain = Nothing,
                              Core.lambdaBody = (Core.TermVariable (Core.Name "x"))})))})),
                          Core.bindingType = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [
                              Core.Name "a"],
                            Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
                              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "a")),
                              Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "a"))})),
                            Core.typeSchemeConstraints = Nothing}))}],
                      Core.letBody = (Core.TermApplication (Core.Application {
                        Core.applicationFunction = (Core.TermApplication (Core.Application {
                          Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm {
                            Core.typeApplicationTermBody = (Core.TermVariable (Core.Name "id")),
                            Core.typeApplicationTermType = (Core.TypeFunction (Core.FunctionType {
                              Core.functionTypeDomain = (Core.TypeLiteral Core.LiteralTypeString),
                              Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
                                Core.functionTypeDomain = (Core.TypeLiteral Core.LiteralTypeString),
                                Core.functionTypeCodomain = (Core.TypeList (Core.TypeLiteral Core.LiteralTypeString))}))}))})),
                          Core.applicationArgument = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.splitOn")))})),
                        Core.applicationArgument = (Core.TermLiteral (Core.LiteralString ","))}))})),
                    Testing.etaExpansionTestCaseOutput = (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "id"),
                          Core.bindingTerm = (Core.TermTypeLambda (Core.TypeLambda {
                            Core.typeLambdaParameter = (Core.Name "a"),
                            Core.typeLambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                              Core.lambdaParameter = (Core.Name "x"),
                              Core.lambdaDomain = Nothing,
                              Core.lambdaBody = (Core.TermVariable (Core.Name "x"))})))})),
                          Core.bindingType = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [
                              Core.Name "a"],
                            Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
                              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "a")),
                              Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "a"))})),
                            Core.typeSchemeConstraints = Nothing}))}],
                      Core.letBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                        Core.lambdaParameter = (Core.Name "v1"),
                        Core.lambdaDomain = Nothing,
                        Core.lambdaBody = (Core.TermApplication (Core.Application {
                          Core.applicationFunction = (Core.TermApplication (Core.Application {
                            Core.applicationFunction = (Core.TermApplication (Core.Application {
                              Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm {
                                Core.typeApplicationTermBody = (Core.TermVariable (Core.Name "id")),
                                Core.typeApplicationTermType = (Core.TypeFunction (Core.FunctionType {
                                  Core.functionTypeDomain = (Core.TypeLiteral Core.LiteralTypeString),
                                  Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
                                    Core.functionTypeDomain = (Core.TypeLiteral Core.LiteralTypeString),
                                    Core.functionTypeCodomain = (Core.TypeList (Core.TypeLiteral Core.LiteralTypeString))}))}))})),
                              Core.applicationArgument = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.splitOn")))})),
                            Core.applicationArgument = (Core.TermLiteral (Core.LiteralString ","))})),
                          Core.applicationArgument = (Core.TermVariable (Core.Name "v1"))}))})))}))})),
                  Testing.testCaseWithMetadataDescription = Nothing,
                  Testing.testCaseWithMetadataTags = []},
                Testing.TestCaseWithMetadata {
                  Testing.testCaseWithMetadataName = "type application of identity applied to binary function, then fully applied to two arguments",
                  Testing.testCaseWithMetadataCase = (Testing.TestCaseEtaExpansion (Testing.EtaExpansionTestCase {
                    Testing.etaExpansionTestCaseInput = (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "id"),
                          Core.bindingTerm = (Core.TermTypeLambda (Core.TypeLambda {
                            Core.typeLambdaParameter = (Core.Name "a"),
                            Core.typeLambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                              Core.lambdaParameter = (Core.Name "x"),
                              Core.lambdaDomain = Nothing,
                              Core.lambdaBody = (Core.TermVariable (Core.Name "x"))})))})),
                          Core.bindingType = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [
                              Core.Name "a"],
                            Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
                              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "a")),
                              Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "a"))})),
                            Core.typeSchemeConstraints = Nothing}))}],
                      Core.letBody = (Core.TermApplication (Core.Application {
                        Core.applicationFunction = (Core.TermApplication (Core.Application {
                          Core.applicationFunction = (Core.TermApplication (Core.Application {
                            Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm {
                              Core.typeApplicationTermBody = (Core.TermVariable (Core.Name "id")),
                              Core.typeApplicationTermType = (Core.TypeFunction (Core.FunctionType {
                                Core.functionTypeDomain = (Core.TypeLiteral Core.LiteralTypeString),
                                Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
                                  Core.functionTypeDomain = (Core.TypeLiteral Core.LiteralTypeString),
                                  Core.functionTypeCodomain = (Core.TypeList (Core.TypeLiteral Core.LiteralTypeString))}))}))})),
                            Core.applicationArgument = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.splitOn")))})),
                          Core.applicationArgument = (Core.TermLiteral (Core.LiteralString ","))})),
                        Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "foo,bar"))}))})),
                    Testing.etaExpansionTestCaseOutput = (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "id"),
                          Core.bindingTerm = (Core.TermTypeLambda (Core.TypeLambda {
                            Core.typeLambdaParameter = (Core.Name "a"),
                            Core.typeLambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                              Core.lambdaParameter = (Core.Name "x"),
                              Core.lambdaDomain = Nothing,
                              Core.lambdaBody = (Core.TermVariable (Core.Name "x"))})))})),
                          Core.bindingType = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [
                              Core.Name "a"],
                            Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
                              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "a")),
                              Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "a"))})),
                            Core.typeSchemeConstraints = Nothing}))}],
                      Core.letBody = (Core.TermApplication (Core.Application {
                        Core.applicationFunction = (Core.TermApplication (Core.Application {
                          Core.applicationFunction = (Core.TermApplication (Core.Application {
                            Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm {
                              Core.typeApplicationTermBody = (Core.TermVariable (Core.Name "id")),
                              Core.typeApplicationTermType = (Core.TypeFunction (Core.FunctionType {
                                Core.functionTypeDomain = (Core.TypeLiteral Core.LiteralTypeString),
                                Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
                                  Core.functionTypeDomain = (Core.TypeLiteral Core.LiteralTypeString),
                                  Core.functionTypeCodomain = (Core.TypeList (Core.TypeLiteral Core.LiteralTypeString))}))}))})),
                            Core.applicationArgument = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.splitOn")))})),
                          Core.applicationArgument = (Core.TermLiteral (Core.LiteralString ","))})),
                        Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "foo,bar"))}))}))})),
                  Testing.testCaseWithMetadataDescription = Nothing,
                  Testing.testCaseWithMetadataTags = []}]}],
          Testing.testGroupCases = []},
        Testing.TestGroup {
          Testing.testGroupName = "Higher-Order Functions",
          Testing.testGroupDescription = Nothing,
          Testing.testGroupSubgroups = [
            Testing.TestGroup {
              Testing.testGroupName = "Functions that return functions",
              Testing.testGroupDescription = Nothing,
              Testing.testGroupSubgroups = [],
              Testing.testGroupCases = [
                Testing.TestCaseWithMetadata {
                  Testing.testCaseWithMetadataName = "lambda returning bare binary primitive",
                  Testing.testCaseWithMetadataCase = (Testing.TestCaseEtaExpansion (Testing.EtaExpansionTestCase {
                    Testing.etaExpansionTestCaseInput = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                      Core.lambdaParameter = (Core.Name "x"),
                      Core.lambdaDomain = Nothing,
                      Core.lambdaBody = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.splitOn")))}))),
                    Testing.etaExpansionTestCaseOutput = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                      Core.lambdaParameter = (Core.Name "x"),
                      Core.lambdaDomain = Nothing,
                      Core.lambdaBody = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.splitOn")))})))})),
                  Testing.testCaseWithMetadataDescription = Nothing,
                  Testing.testCaseWithMetadataTags = []},
                Testing.TestCaseWithMetadata {
                  Testing.testCaseWithMetadataName = "lambda returning bare unary primitive",
                  Testing.testCaseWithMetadataCase = (Testing.TestCaseEtaExpansion (Testing.EtaExpansionTestCase {
                    Testing.etaExpansionTestCaseInput = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                      Core.lambdaParameter = (Core.Name "x"),
                      Core.lambdaDomain = Nothing,
                      Core.lambdaBody = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.toLower")))}))),
                    Testing.etaExpansionTestCaseOutput = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                      Core.lambdaParameter = (Core.Name "x"),
                      Core.lambdaDomain = Nothing,
                      Core.lambdaBody = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.toLower")))})))})),
                  Testing.testCaseWithMetadataDescription = Nothing,
                  Testing.testCaseWithMetadataTags = []},
                Testing.TestCaseWithMetadata {
                  Testing.testCaseWithMetadataName = "lambda returning partially applied primitive",
                  Testing.testCaseWithMetadataCase = (Testing.TestCaseEtaExpansion (Testing.EtaExpansionTestCase {
                    Testing.etaExpansionTestCaseInput = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                      Core.lambdaParameter = (Core.Name "x"),
                      Core.lambdaDomain = Nothing,
                      Core.lambdaBody = (Core.TermApplication (Core.Application {
                        Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.splitOn"))),
                        Core.applicationArgument = (Core.TermLiteral (Core.LiteralString ","))}))}))),
                    Testing.etaExpansionTestCaseOutput = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                      Core.lambdaParameter = (Core.Name "x"),
                      Core.lambdaDomain = Nothing,
                      Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                        Core.lambdaParameter = (Core.Name "v1"),
                        Core.lambdaDomain = Nothing,
                        Core.lambdaBody = (Core.TermApplication (Core.Application {
                          Core.applicationFunction = (Core.TermApplication (Core.Application {
                            Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.splitOn"))),
                            Core.applicationArgument = (Core.TermLiteral (Core.LiteralString ","))})),
                          Core.applicationArgument = (Core.TermVariable (Core.Name "v1"))}))})))})))})),
                  Testing.testCaseWithMetadataDescription = Nothing,
                  Testing.testCaseWithMetadataTags = []},
                Testing.TestCaseWithMetadata {
                  Testing.testCaseWithMetadataName = "lambda returning fully applied primitive",
                  Testing.testCaseWithMetadataCase = (Testing.TestCaseEtaExpansion (Testing.EtaExpansionTestCase {
                    Testing.etaExpansionTestCaseInput = (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.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.splitOn"))),
                          Core.applicationArgument = (Core.TermLiteral (Core.LiteralString ","))})),
                        Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))),
                    Testing.etaExpansionTestCaseOutput = (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.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.splitOn"))),
                          Core.applicationArgument = (Core.TermLiteral (Core.LiteralString ","))})),
                        Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))})))})),
                  Testing.testCaseWithMetadataDescription = Nothing,
                  Testing.testCaseWithMetadataTags = []},
                Testing.TestCaseWithMetadata {
                  Testing.testCaseWithMetadataName = "lambda returning bare projection",
                  Testing.testCaseWithMetadataCase = (Testing.TestCaseEtaExpansion (Testing.EtaExpansionTestCase {
                    Testing.etaExpansionTestCaseInput = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                      Core.lambdaParameter = (Core.Name "person"),
                      Core.lambdaDomain = Nothing,
                      Core.lambdaBody = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection {
                        Core.projectionTypeName = TestTypes.testTypePersonName,
                        Core.projectionField = (Core.Name "firstName")}))))}))),
                    Testing.etaExpansionTestCaseOutput = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                      Core.lambdaParameter = (Core.Name "person"),
                      Core.lambdaDomain = Nothing,
                      Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                        Core.lambdaParameter = (Core.Name "v1"),
                        Core.lambdaDomain = Nothing,
                        Core.lambdaBody = (Core.TermApplication (Core.Application {
                          Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection {
                            Core.projectionTypeName = TestTypes.testTypePersonName,
                            Core.projectionField = (Core.Name "firstName")})))),
                          Core.applicationArgument = (Core.TermVariable (Core.Name "v1"))}))})))})))})),
                  Testing.testCaseWithMetadataDescription = Nothing,
                  Testing.testCaseWithMetadataTags = []},
                Testing.TestCaseWithMetadata {
                  Testing.testCaseWithMetadataName = "nested lambdas with partial application in body",
                  Testing.testCaseWithMetadataCase = (Testing.TestCaseEtaExpansion (Testing.EtaExpansionTestCase {
                    Testing.etaExpansionTestCaseInput = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                      Core.lambdaParameter = (Core.Name "x"),
                      Core.lambdaDomain = Nothing,
                      Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                        Core.lambdaParameter = (Core.Name "y"),
                        Core.lambdaDomain = Nothing,
                        Core.lambdaBody = (Core.TermApplication (Core.Application {
                          Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.splitOn"))),
                          Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))})))}))),
                    Testing.etaExpansionTestCaseOutput = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                      Core.lambdaParameter = (Core.Name "x"),
                      Core.lambdaDomain = Nothing,
                      Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                        Core.lambdaParameter = (Core.Name "y"),
                        Core.lambdaDomain = Nothing,
                        Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                          Core.lambdaParameter = (Core.Name "v1"),
                          Core.lambdaDomain = Nothing,
                          Core.lambdaBody = (Core.TermApplication (Core.Application {
                            Core.applicationFunction = (Core.TermApplication (Core.Application {
                              Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.splitOn"))),
                              Core.applicationArgument = (Core.TermVariable (Core.Name "x"))})),
                            Core.applicationArgument = (Core.TermVariable (Core.Name "v1"))}))})))})))})))})),
                  Testing.testCaseWithMetadataDescription = Nothing,
                  Testing.testCaseWithMetadataTags = []},
                Testing.TestCaseWithMetadata {
                  Testing.testCaseWithMetadataName = "lambda returning lambda returning partial application",
                  Testing.testCaseWithMetadataCase = (Testing.TestCaseEtaExpansion (Testing.EtaExpansionTestCase {
                    Testing.etaExpansionTestCaseInput = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                      Core.lambdaParameter = (Core.Name "x"),
                      Core.lambdaDomain = Nothing,
                      Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                        Core.lambdaParameter = (Core.Name "y"),
                        Core.lambdaDomain = Nothing,
                        Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                          Core.lambdaParameter = (Core.Name "z"),
                          Core.lambdaDomain = Nothing,
                          Core.lambdaBody = (Core.TermApplication (Core.Application {
                            Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.splitOn"))),
                            Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))})))})))}))),
                    Testing.etaExpansionTestCaseOutput = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                      Core.lambdaParameter = (Core.Name "x"),
                      Core.lambdaDomain = Nothing,
                      Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                        Core.lambdaParameter = (Core.Name "y"),
                        Core.lambdaDomain = Nothing,
                        Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                          Core.lambdaParameter = (Core.Name "z"),
                          Core.lambdaDomain = Nothing,
                          Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                            Core.lambdaParameter = (Core.Name "v1"),
                            Core.lambdaDomain = Nothing,
                            Core.lambdaBody = (Core.TermApplication (Core.Application {
                              Core.applicationFunction = (Core.TermApplication (Core.Application {
                                Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.splitOn"))),
                                Core.applicationArgument = (Core.TermVariable (Core.Name "x"))})),
                              Core.applicationArgument = (Core.TermVariable (Core.Name "v1"))}))})))})))})))})))})),
                  Testing.testCaseWithMetadataDescription = Nothing,
                  Testing.testCaseWithMetadataTags = []}]}],
          Testing.testGroupCases = []},
        Testing.TestGroup {
          Testing.testGroupName = "Let terms",
          Testing.testGroupDescription = Nothing,
          Testing.testGroupSubgroups = [
            Testing.TestGroup {
              Testing.testGroupName = "partial application of a let-bound function",
              Testing.testGroupDescription = Nothing,
              Testing.testGroupSubgroups = [],
              Testing.testGroupCases = [
                Testing.TestCaseWithMetadata {
                  Testing.testCaseWithMetadataName = "simple",
                  Testing.testCaseWithMetadataCase = (Testing.TestCaseEtaExpansion (Testing.EtaExpansionTestCase {
                    Testing.etaExpansionTestCaseInput = (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "helper"),
                          Core.bindingTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                            Core.lambdaParameter = (Core.Name "arg1"),
                            Core.lambdaDomain = Nothing,
                            Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                              Core.lambdaParameter = (Core.Name "arg2"),
                              Core.lambdaDomain = Nothing,
                              Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                                Core.lambdaParameter = (Core.Name "arg3"),
                                Core.lambdaDomain = Nothing,
                                Core.lambdaBody = (Core.TermApplication (Core.Application {
                                  Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.cat"))),
                                  Core.applicationArgument = (Core.TermList [
                                    Core.TermVariable (Core.Name "arg1"),
                                    (Core.TermVariable (Core.Name "arg2")),
                                    (Core.TermVariable (Core.Name "arg3"))])}))})))})))}))),
                          Core.bindingType = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [],
                            Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
                              Core.functionTypeDomain = (Core.TypeLiteral Core.LiteralTypeString),
                              Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
                                Core.functionTypeDomain = (Core.TypeLiteral Core.LiteralTypeString),
                                Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
                                  Core.functionTypeDomain = (Core.TypeLiteral Core.LiteralTypeString),
                                  Core.functionTypeCodomain = (Core.TypeLiteral Core.LiteralTypeString)}))}))})),
                            Core.typeSchemeConstraints = Nothing}))}],
                      Core.letBody = (Core.TermApplication (Core.Application {
                        Core.applicationFunction = (Core.TermVariable (Core.Name "helper")),
                        Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "foo"))}))})),
                    Testing.etaExpansionTestCaseOutput = (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "helper"),
                          Core.bindingTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                            Core.lambdaParameter = (Core.Name "arg1"),
                            Core.lambdaDomain = Nothing,
                            Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                              Core.lambdaParameter = (Core.Name "arg2"),
                              Core.lambdaDomain = Nothing,
                              Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                                Core.lambdaParameter = (Core.Name "arg3"),
                                Core.lambdaDomain = Nothing,
                                Core.lambdaBody = (Core.TermApplication (Core.Application {
                                  Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.cat"))),
                                  Core.applicationArgument = (Core.TermList [
                                    Core.TermVariable (Core.Name "arg1"),
                                    (Core.TermVariable (Core.Name "arg2")),
                                    (Core.TermVariable (Core.Name "arg3"))])}))})))})))}))),
                          Core.bindingType = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [],
                            Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
                              Core.functionTypeDomain = (Core.TypeLiteral Core.LiteralTypeString),
                              Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
                                Core.functionTypeDomain = (Core.TypeLiteral Core.LiteralTypeString),
                                Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
                                  Core.functionTypeDomain = (Core.TypeLiteral Core.LiteralTypeString),
                                  Core.functionTypeCodomain = (Core.TypeLiteral Core.LiteralTypeString)}))}))})),
                            Core.typeSchemeConstraints = Nothing}))}],
                      Core.letBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                        Core.lambdaParameter = (Core.Name "v1"),
                        Core.lambdaDomain = Nothing,
                        Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                          Core.lambdaParameter = (Core.Name "v2"),
                          Core.lambdaDomain = Nothing,
                          Core.lambdaBody = (Core.TermApplication (Core.Application {
                            Core.applicationFunction = (Core.TermApplication (Core.Application {
                              Core.applicationFunction = (Core.TermApplication (Core.Application {
                                Core.applicationFunction = (Core.TermVariable (Core.Name "helper")),
                                Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "foo"))})),
                              Core.applicationArgument = (Core.TermVariable (Core.Name "v1"))})),
                            Core.applicationArgument = (Core.TermVariable (Core.Name "v2"))}))})))})))}))})),
                  Testing.testCaseWithMetadataDescription = Nothing,
                  Testing.testCaseWithMetadataTags = []},
                Testing.TestCaseWithMetadata {
                  Testing.testCaseWithMetadataName = "in a fold",
                  Testing.testCaseWithMetadataCase = (Testing.TestCaseEtaExpansion (Testing.EtaExpansionTestCase {
                    Testing.etaExpansionTestCaseInput = (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "helper"),
                          Core.bindingTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                            Core.lambdaParameter = (Core.Name "arg1"),
                            Core.lambdaDomain = Nothing,
                            Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                              Core.lambdaParameter = (Core.Name "arg2"),
                              Core.lambdaDomain = Nothing,
                              Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                                Core.lambdaParameter = (Core.Name "arg3"),
                                Core.lambdaDomain = Nothing,
                                Core.lambdaBody = (Core.TermApplication (Core.Application {
                                  Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.cat"))),
                                  Core.applicationArgument = (Core.TermList [
                                    Core.TermVariable (Core.Name "arg1"),
                                    (Core.TermVariable (Core.Name "arg2")),
                                    (Core.TermVariable (Core.Name "arg3"))])}))})))})))}))),
                          Core.bindingType = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [],
                            Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
                              Core.functionTypeDomain = (Core.TypeLiteral Core.LiteralTypeString),
                              Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
                                Core.functionTypeDomain = (Core.TypeLiteral Core.LiteralTypeString),
                                Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
                                  Core.functionTypeDomain = (Core.TypeLiteral Core.LiteralTypeString),
                                  Core.functionTypeCodomain = (Core.TypeLiteral Core.LiteralTypeString)}))}))})),
                            Core.typeSchemeConstraints = Nothing}))}],
                      Core.letBody = (Core.TermApplication (Core.Application {
                        Core.applicationFunction = (Core.TermApplication (Core.Application {
                          Core.applicationFunction = (Core.TermApplication (Core.Application {
                            Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm {
                              Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm {
                                Core.typeApplicationTermBody = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.lists.foldl"))),
                                Core.typeApplicationTermType = (Core.TypeLiteral Core.LiteralTypeString)})),
                              Core.typeApplicationTermType = (Core.TypeLiteral Core.LiteralTypeString)})),
                            Core.applicationArgument = (Core.TermApplication (Core.Application {
                              Core.applicationFunction = (Core.TermVariable (Core.Name "helper")),
                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "foo"))}))})),
                          Core.applicationArgument = (Core.TermLiteral (Core.LiteralString ""))})),
                        Core.applicationArgument = (Core.TermList [
                          Core.TermLiteral (Core.LiteralString "bar"),
                          (Core.TermLiteral (Core.LiteralString "baz"))])}))})),
                    Testing.etaExpansionTestCaseOutput = (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "helper"),
                          Core.bindingTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                            Core.lambdaParameter = (Core.Name "arg1"),
                            Core.lambdaDomain = Nothing,
                            Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                              Core.lambdaParameter = (Core.Name "arg2"),
                              Core.lambdaDomain = Nothing,
                              Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                                Core.lambdaParameter = (Core.Name "arg3"),
                                Core.lambdaDomain = Nothing,
                                Core.lambdaBody = (Core.TermApplication (Core.Application {
                                  Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.cat"))),
                                  Core.applicationArgument = (Core.TermList [
                                    Core.TermVariable (Core.Name "arg1"),
                                    (Core.TermVariable (Core.Name "arg2")),
                                    (Core.TermVariable (Core.Name "arg3"))])}))})))})))}))),
                          Core.bindingType = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [],
                            Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
                              Core.functionTypeDomain = (Core.TypeLiteral Core.LiteralTypeString),
                              Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
                                Core.functionTypeDomain = (Core.TypeLiteral Core.LiteralTypeString),
                                Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
                                  Core.functionTypeDomain = (Core.TypeLiteral Core.LiteralTypeString),
                                  Core.functionTypeCodomain = (Core.TypeLiteral Core.LiteralTypeString)}))}))})),
                            Core.typeSchemeConstraints = Nothing}))}],
                      Core.letBody = (Core.TermApplication (Core.Application {
                        Core.applicationFunction = (Core.TermApplication (Core.Application {
                          Core.applicationFunction = (Core.TermApplication (Core.Application {
                            Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm {
                              Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm {
                                Core.typeApplicationTermBody = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.lists.foldl"))),
                                Core.typeApplicationTermType = (Core.TypeLiteral Core.LiteralTypeString)})),
                              Core.typeApplicationTermType = (Core.TypeLiteral Core.LiteralTypeString)})),
                            Core.applicationArgument = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                              Core.lambdaParameter = (Core.Name "v1"),
                              Core.lambdaDomain = Nothing,
                              Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                                Core.lambdaParameter = (Core.Name "v2"),
                                Core.lambdaDomain = Nothing,
                                Core.lambdaBody = (Core.TermApplication (Core.Application {
                                  Core.applicationFunction = (Core.TermApplication (Core.Application {
                                    Core.applicationFunction = (Core.TermApplication (Core.Application {
                                      Core.applicationFunction = (Core.TermVariable (Core.Name "helper")),
                                      Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "foo"))})),
                                    Core.applicationArgument = (Core.TermVariable (Core.Name "v1"))})),
                                  Core.applicationArgument = (Core.TermVariable (Core.Name "v2"))}))})))})))})),
                          Core.applicationArgument = (Core.TermLiteral (Core.LiteralString ""))})),
                        Core.applicationArgument = (Core.TermList [
                          Core.TermLiteral (Core.LiteralString "bar"),
                          (Core.TermLiteral (Core.LiteralString "baz"))])}))}))})),
                  Testing.testCaseWithMetadataDescription = Nothing,
                  Testing.testCaseWithMetadataTags = []},
                Testing.TestCaseWithMetadata {
                  Testing.testCaseWithMetadataName = "within another let binding",
                  Testing.testCaseWithMetadataCase = (Testing.TestCaseEtaExpansion (Testing.EtaExpansionTestCase {
                    Testing.etaExpansionTestCaseInput = (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "tryme"),
                          Core.bindingTerm = (Core.TermLet (Core.Let {
                            Core.letBindings = [
                              Core.Binding {
                                Core.bindingName = (Core.Name "helper"),
                                Core.bindingTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                                  Core.lambdaParameter = (Core.Name "arg1"),
                                  Core.lambdaDomain = Nothing,
                                  Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                                    Core.lambdaParameter = (Core.Name "arg2"),
                                    Core.lambdaDomain = Nothing,
                                    Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                                      Core.lambdaParameter = (Core.Name "arg3"),
                                      Core.lambdaDomain = Nothing,
                                      Core.lambdaBody = (Core.TermApplication (Core.Application {
                                        Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.cat"))),
                                        Core.applicationArgument = (Core.TermList [
                                          Core.TermVariable (Core.Name "arg1"),
                                          (Core.TermVariable (Core.Name "arg2")),
                                          (Core.TermVariable (Core.Name "arg3"))])}))})))})))}))),
                                Core.bindingType = (Just (Core.TypeScheme {
                                  Core.typeSchemeVariables = [],
                                  Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
                                    Core.functionTypeDomain = (Core.TypeLiteral Core.LiteralTypeString),
                                    Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
                                      Core.functionTypeDomain = (Core.TypeLiteral Core.LiteralTypeString),
                                      Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
                                        Core.functionTypeDomain = (Core.TypeLiteral Core.LiteralTypeString),
                                        Core.functionTypeCodomain = (Core.TypeLiteral Core.LiteralTypeString)}))}))})),
                                  Core.typeSchemeConstraints = Nothing}))}],
                            Core.letBody = (Core.TermApplication (Core.Application {
                              Core.applicationFunction = (Core.TermVariable (Core.Name "helper")),
                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "foo"))}))})),
                          Core.bindingType = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [],
                            Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
                              Core.functionTypeDomain = (Core.TypeLiteral Core.LiteralTypeString),
                              Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
                                Core.functionTypeDomain = (Core.TypeLiteral Core.LiteralTypeString),
                                Core.functionTypeCodomain = (Core.TypeLiteral Core.LiteralTypeString)}))})),
                            Core.typeSchemeConstraints = Nothing}))}],
                      Core.letBody = Core.TermUnit})),
                    Testing.etaExpansionTestCaseOutput = (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "tryme"),
                          Core.bindingTerm = (Core.TermLet (Core.Let {
                            Core.letBindings = [
                              Core.Binding {
                                Core.bindingName = (Core.Name "helper"),
                                Core.bindingTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                                  Core.lambdaParameter = (Core.Name "arg1"),
                                  Core.lambdaDomain = Nothing,
                                  Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                                    Core.lambdaParameter = (Core.Name "arg2"),
                                    Core.lambdaDomain = Nothing,
                                    Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                                      Core.lambdaParameter = (Core.Name "arg3"),
                                      Core.lambdaDomain = Nothing,
                                      Core.lambdaBody = (Core.TermApplication (Core.Application {
                                        Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.cat"))),
                                        Core.applicationArgument = (Core.TermList [
                                          Core.TermVariable (Core.Name "arg1"),
                                          (Core.TermVariable (Core.Name "arg2")),
                                          (Core.TermVariable (Core.Name "arg3"))])}))})))})))}))),
                                Core.bindingType = (Just (Core.TypeScheme {
                                  Core.typeSchemeVariables = [],
                                  Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
                                    Core.functionTypeDomain = (Core.TypeLiteral Core.LiteralTypeString),
                                    Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
                                      Core.functionTypeDomain = (Core.TypeLiteral Core.LiteralTypeString),
                                      Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
                                        Core.functionTypeDomain = (Core.TypeLiteral Core.LiteralTypeString),
                                        Core.functionTypeCodomain = (Core.TypeLiteral Core.LiteralTypeString)}))}))})),
                                  Core.typeSchemeConstraints = Nothing}))}],
                            Core.letBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                              Core.lambdaParameter = (Core.Name "v1"),
                              Core.lambdaDomain = Nothing,
                              Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                                Core.lambdaParameter = (Core.Name "v2"),
                                Core.lambdaDomain = Nothing,
                                Core.lambdaBody = (Core.TermApplication (Core.Application {
                                  Core.applicationFunction = (Core.TermApplication (Core.Application {
                                    Core.applicationFunction = (Core.TermApplication (Core.Application {
                                      Core.applicationFunction = (Core.TermVariable (Core.Name "helper")),
                                      Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "foo"))})),
                                    Core.applicationArgument = (Core.TermVariable (Core.Name "v1"))})),
                                  Core.applicationArgument = (Core.TermVariable (Core.Name "v2"))}))})))})))})),
                          Core.bindingType = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [],
                            Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
                              Core.functionTypeDomain = (Core.TypeLiteral Core.LiteralTypeString),
                              Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {
                                Core.functionTypeDomain = (Core.TypeLiteral Core.LiteralTypeString),
                                Core.functionTypeCodomain = (Core.TypeLiteral Core.LiteralTypeString)}))})),
                            Core.typeSchemeConstraints = Nothing}))}],
                      Core.letBody = Core.TermUnit}))})),
                  Testing.testCaseWithMetadataDescription = Nothing,
                  Testing.testCaseWithMetadataTags = []}]}],
          Testing.testGroupCases = []},
        Testing.TestGroup {
          Testing.testGroupName = "Case statements",
          Testing.testGroupDescription = Nothing,
          Testing.testGroupSubgroups = [
            Testing.TestGroup {
              Testing.testGroupName = "monomorphic at top level",
              Testing.testGroupDescription = Nothing,
              Testing.testGroupSubgroups = [],
              Testing.testGroupCases = [
                Testing.TestCaseWithMetadata {
                  Testing.testCaseWithMetadataName = "non-applied case statement",
                  Testing.testCaseWithMetadataCase = (Testing.TestCaseEtaExpansion (Testing.EtaExpansionTestCase {
                    Testing.etaExpansionTestCaseInput = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
                      Core.caseStatementTypeName = TestTypes.testTypeUnionMonomorphicName,
                      Core.caseStatementDefault = (Just (Core.TermLiteral (Core.LiteralString "other"))),
                      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.TermVariable (Core.Name "s"))})))}]})))),
                    Testing.etaExpansionTestCaseOutput = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                      Core.lambdaParameter = (Core.Name "v1"),
                      Core.lambdaDomain = Nothing,
                      Core.lambdaBody = (Core.TermApplication (Core.Application {
                        Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
                          Core.caseStatementTypeName = TestTypes.testTypeUnionMonomorphicName,
                          Core.caseStatementDefault = (Just (Core.TermLiteral (Core.LiteralString "other"))),
                          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.TermVariable (Core.Name "s"))})))}]})))),
                        Core.applicationArgument = (Core.TermVariable (Core.Name "v1"))}))})))})),
                  Testing.testCaseWithMetadataDescription = Nothing,
                  Testing.testCaseWithMetadataTags = []},
                Testing.TestCaseWithMetadata {
                  Testing.testCaseWithMetadataName = "applied case statement",
                  Testing.testCaseWithMetadataCase = (Testing.TestCaseEtaExpansion (Testing.EtaExpansionTestCase {
                    Testing.etaExpansionTestCaseInput = (Core.TermApplication (Core.Application {
                      Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
                        Core.caseStatementTypeName = TestTypes.testTypeUnionMonomorphicName,
                        Core.caseStatementDefault = (Just (Core.TermLiteral (Core.LiteralString "other"))),
                        Core.caseStatementCases = [
                          Core.Field {
                            Core.fieldName = (Core.Name "string"),
                            Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                              Core.lambdaParameter = (Core.Name "s"),
                              Core.lambdaDomain = (Just (Core.TypeLiteral Core.LiteralTypeString)),
                              Core.lambdaBody = (Core.TermVariable (Core.Name "s"))})))}]})))),
                      Core.applicationArgument = (Core.TermUnion (Core.Injection {
                        Core.injectionTypeName = TestTypes.testTypeUnionMonomorphicName,
                        Core.injectionField = Core.Field {
                          Core.fieldName = (Core.Name "string"),
                          Core.fieldTerm = (Core.TermLiteral (Core.LiteralString "foo"))}}))})),
                    Testing.etaExpansionTestCaseOutput = (Core.TermApplication (Core.Application {
                      Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
                        Core.caseStatementTypeName = TestTypes.testTypeUnionMonomorphicName,
                        Core.caseStatementDefault = (Just (Core.TermLiteral (Core.LiteralString "other"))),
                        Core.caseStatementCases = [
                          Core.Field {
                            Core.fieldName = (Core.Name "string"),
                            Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                              Core.lambdaParameter = (Core.Name "s"),
                              Core.lambdaDomain = (Just (Core.TypeLiteral Core.LiteralTypeString)),
                              Core.lambdaBody = (Core.TermVariable (Core.Name "s"))})))}]})))),
                      Core.applicationArgument = (Core.TermUnion (Core.Injection {
                        Core.injectionTypeName = TestTypes.testTypeUnionMonomorphicName,
                        Core.injectionField = Core.Field {
                          Core.fieldName = (Core.Name "string"),
                          Core.fieldTerm = (Core.TermLiteral (Core.LiteralString "foo"))}}))}))})),
                  Testing.testCaseWithMetadataDescription = Nothing,
                  Testing.testCaseWithMetadataTags = []},
                Testing.TestCaseWithMetadata {
                  Testing.testCaseWithMetadataName = "applied case statement in lambda",
                  Testing.testCaseWithMetadataCase = (Testing.TestCaseEtaExpansion (Testing.EtaExpansionTestCase {
                    Testing.etaExpansionTestCaseInput = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                      Core.lambdaParameter = (Core.Name "x"),
                      Core.lambdaDomain = (Just (Core.TypeVariable TestTypes.testTypeUnionMonomorphicName)),
                      Core.lambdaBody = (Core.TermApplication (Core.Application {
                        Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
                          Core.caseStatementTypeName = TestTypes.testTypeUnionMonomorphicName,
                          Core.caseStatementDefault = (Just (Core.TermLiteral (Core.LiteralString "other"))),
                          Core.caseStatementCases = [
                            Core.Field {
                              Core.fieldName = (Core.Name "string"),
                              Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                                Core.lambdaParameter = (Core.Name "s"),
                                Core.lambdaDomain = (Just (Core.TypeLiteral Core.LiteralTypeString)),
                                Core.lambdaBody = (Core.TermVariable (Core.Name "s"))})))}]})))),
                        Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))),
                    Testing.etaExpansionTestCaseOutput = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                      Core.lambdaParameter = (Core.Name "x"),
                      Core.lambdaDomain = (Just (Core.TypeVariable TestTypes.testTypeUnionMonomorphicName)),
                      Core.lambdaBody = (Core.TermApplication (Core.Application {
                        Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
                          Core.caseStatementTypeName = TestTypes.testTypeUnionMonomorphicName,
                          Core.caseStatementDefault = (Just (Core.TermLiteral (Core.LiteralString "other"))),
                          Core.caseStatementCases = [
                            Core.Field {
                              Core.fieldName = (Core.Name "string"),
                              Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                                Core.lambdaParameter = (Core.Name "s"),
                                Core.lambdaDomain = (Just (Core.TypeLiteral Core.LiteralTypeString)),
                                Core.lambdaBody = (Core.TermVariable (Core.Name "s"))})))}]})))),
                        Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))})))})),
                  Testing.testCaseWithMetadataDescription = Nothing,
                  Testing.testCaseWithMetadataTags = []}]},
            Testing.TestGroup {
              Testing.testGroupName = "monomorphic in let binding",
              Testing.testGroupDescription = Nothing,
              Testing.testGroupSubgroups = [],
              Testing.testGroupCases = [
                Testing.TestCaseWithMetadata {
                  Testing.testCaseWithMetadataName = "non-applied case statement",
                  Testing.testCaseWithMetadataCase = (Testing.TestCaseEtaExpansion (Testing.EtaExpansionTestCase {
                    Testing.etaExpansionTestCaseInput = (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "test"),
                          Core.bindingTerm = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
                            Core.caseStatementTypeName = TestTypes.testTypeUnionMonomorphicName,
                            Core.caseStatementDefault = (Just (Core.TermLiteral (Core.LiteralString "other"))),
                            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.TermVariable (Core.Name "s"))})))}]})))),
                          Core.bindingType = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [],
                            Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
                              Core.functionTypeDomain = (Core.TypeVariable TestTypes.testTypeUnionMonomorphicName),
                              Core.functionTypeCodomain = (Core.TypeLiteral Core.LiteralTypeString)})),
                            Core.typeSchemeConstraints = Nothing}))}],
                      Core.letBody = (Core.TermLiteral (Core.LiteralString "ignored"))})),
                    Testing.etaExpansionTestCaseOutput = (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "test"),
                          Core.bindingTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                            Core.lambdaParameter = (Core.Name "v1"),
                            Core.lambdaDomain = Nothing,
                            Core.lambdaBody = (Core.TermApplication (Core.Application {
                              Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
                                Core.caseStatementTypeName = TestTypes.testTypeUnionMonomorphicName,
                                Core.caseStatementDefault = (Just (Core.TermLiteral (Core.LiteralString "other"))),
                                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.TermVariable (Core.Name "s"))})))}]})))),
                              Core.applicationArgument = (Core.TermVariable (Core.Name "v1"))}))}))),
                          Core.bindingType = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [],
                            Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
                              Core.functionTypeDomain = (Core.TypeVariable TestTypes.testTypeUnionMonomorphicName),
                              Core.functionTypeCodomain = (Core.TypeLiteral Core.LiteralTypeString)})),
                            Core.typeSchemeConstraints = Nothing}))}],
                      Core.letBody = (Core.TermLiteral (Core.LiteralString "ignored"))}))})),
                  Testing.testCaseWithMetadataDescription = Nothing,
                  Testing.testCaseWithMetadataTags = []},
                Testing.TestCaseWithMetadata {
                  Testing.testCaseWithMetadataName = "applied case statement",
                  Testing.testCaseWithMetadataCase = (Testing.TestCaseEtaExpansion (Testing.EtaExpansionTestCase {
                    Testing.etaExpansionTestCaseInput = (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "test"),
                          Core.bindingTerm = (Core.TermApplication (Core.Application {
                            Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
                              Core.caseStatementTypeName = TestTypes.testTypeUnionMonomorphicName,
                              Core.caseStatementDefault = (Just (Core.TermLiteral (Core.LiteralString "other"))),
                              Core.caseStatementCases = [
                                Core.Field {
                                  Core.fieldName = (Core.Name "string"),
                                  Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                                    Core.lambdaParameter = (Core.Name "s"),
                                    Core.lambdaDomain = (Just (Core.TypeLiteral Core.LiteralTypeString)),
                                    Core.lambdaBody = (Core.TermVariable (Core.Name "s"))})))}]})))),
                            Core.applicationArgument = (Core.TermUnion (Core.Injection {
                              Core.injectionTypeName = TestTypes.testTypeUnionMonomorphicName,
                              Core.injectionField = Core.Field {
                                Core.fieldName = (Core.Name "string"),
                                Core.fieldTerm = (Core.TermLiteral (Core.LiteralString "foo"))}}))})),
                          Core.bindingType = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [],
                            Core.typeSchemeType = (Core.TypeLiteral Core.LiteralTypeString),
                            Core.typeSchemeConstraints = Nothing}))}],
                      Core.letBody = (Core.TermLiteral (Core.LiteralString "ignored"))})),
                    Testing.etaExpansionTestCaseOutput = (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "test"),
                          Core.bindingTerm = (Core.TermApplication (Core.Application {
                            Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
                              Core.caseStatementTypeName = TestTypes.testTypeUnionMonomorphicName,
                              Core.caseStatementDefault = (Just (Core.TermLiteral (Core.LiteralString "other"))),
                              Core.caseStatementCases = [
                                Core.Field {
                                  Core.fieldName = (Core.Name "string"),
                                  Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                                    Core.lambdaParameter = (Core.Name "s"),
                                    Core.lambdaDomain = (Just (Core.TypeLiteral Core.LiteralTypeString)),
                                    Core.lambdaBody = (Core.TermVariable (Core.Name "s"))})))}]})))),
                            Core.applicationArgument = (Core.TermUnion (Core.Injection {
                              Core.injectionTypeName = TestTypes.testTypeUnionMonomorphicName,
                              Core.injectionField = Core.Field {
                                Core.fieldName = (Core.Name "string"),
                                Core.fieldTerm = (Core.TermLiteral (Core.LiteralString "foo"))}}))})),
                          Core.bindingType = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [],
                            Core.typeSchemeType = (Core.TypeLiteral Core.LiteralTypeString),
                            Core.typeSchemeConstraints = Nothing}))}],
                      Core.letBody = (Core.TermLiteral (Core.LiteralString "ignored"))}))})),
                  Testing.testCaseWithMetadataDescription = Nothing,
                  Testing.testCaseWithMetadataTags = []},
                Testing.TestCaseWithMetadata {
                  Testing.testCaseWithMetadataName = "applied case statement in lambda",
                  Testing.testCaseWithMetadataCase = (Testing.TestCaseEtaExpansion (Testing.EtaExpansionTestCase {
                    Testing.etaExpansionTestCaseInput = (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "test"),
                          Core.bindingTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                            Core.lambdaParameter = (Core.Name "x"),
                            Core.lambdaDomain = (Just (Core.TypeVariable TestTypes.testTypeUnionMonomorphicName)),
                            Core.lambdaBody = (Core.TermApplication (Core.Application {
                              Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
                                Core.caseStatementTypeName = TestTypes.testTypeUnionMonomorphicName,
                                Core.caseStatementDefault = (Just (Core.TermLiteral (Core.LiteralString "other"))),
                                Core.caseStatementCases = [
                                  Core.Field {
                                    Core.fieldName = (Core.Name "string"),
                                    Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                                      Core.lambdaParameter = (Core.Name "s"),
                                      Core.lambdaDomain = (Just (Core.TypeLiteral Core.LiteralTypeString)),
                                      Core.lambdaBody = (Core.TermVariable (Core.Name "s"))})))}]})))),
                              Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))),
                          Core.bindingType = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [],
                            Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
                              Core.functionTypeDomain = (Core.TypeLiteral Core.LiteralTypeString),
                              Core.functionTypeCodomain = (Core.TypeLiteral Core.LiteralTypeString)})),
                            Core.typeSchemeConstraints = Nothing}))}],
                      Core.letBody = (Core.TermLiteral (Core.LiteralString "ignored"))})),
                    Testing.etaExpansionTestCaseOutput = (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "test"),
                          Core.bindingTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                            Core.lambdaParameter = (Core.Name "x"),
                            Core.lambdaDomain = (Just (Core.TypeVariable TestTypes.testTypeUnionMonomorphicName)),
                            Core.lambdaBody = (Core.TermApplication (Core.Application {
                              Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
                                Core.caseStatementTypeName = TestTypes.testTypeUnionMonomorphicName,
                                Core.caseStatementDefault = (Just (Core.TermLiteral (Core.LiteralString "other"))),
                                Core.caseStatementCases = [
                                  Core.Field {
                                    Core.fieldName = (Core.Name "string"),
                                    Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                                      Core.lambdaParameter = (Core.Name "s"),
                                      Core.lambdaDomain = (Just (Core.TypeLiteral Core.LiteralTypeString)),
                                      Core.lambdaBody = (Core.TermVariable (Core.Name "s"))})))}]})))),
                              Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))),
                          Core.bindingType = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [],
                            Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
                              Core.functionTypeDomain = (Core.TypeLiteral Core.LiteralTypeString),
                              Core.functionTypeCodomain = (Core.TypeLiteral Core.LiteralTypeString)})),
                            Core.typeSchemeConstraints = Nothing}))}],
                      Core.letBody = (Core.TermLiteral (Core.LiteralString "ignored"))}))})),
                  Testing.testCaseWithMetadataDescription = Nothing,
                  Testing.testCaseWithMetadataTags = []}]},
            Testing.TestGroup {
              Testing.testGroupName = "polymorphic in let binding",
              Testing.testGroupDescription = Nothing,
              Testing.testGroupSubgroups = [],
              Testing.testGroupCases = [
                Testing.TestCaseWithMetadata {
                  Testing.testCaseWithMetadataName = "non-applied UnionPolymorphicRecursive",
                  Testing.testCaseWithMetadataCase = (Testing.TestCaseEtaExpansion (Testing.EtaExpansionTestCase {
                    Testing.etaExpansionTestCaseInput = (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "test"),
                          Core.bindingTerm = (Core.TermTypeApplication (Core.TypeApplicationTerm {
                            Core.typeApplicationTermBody = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
                              Core.caseStatementTypeName = TestTypes.testTypeUnionPolymorphicRecursiveName,
                              Core.caseStatementDefault = (Just (Core.TermLiteral (Core.LiteralString "other"))),
                              Core.caseStatementCases = [
                                Core.Field {
                                  Core.fieldName = (Core.Name "value"),
                                  Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                                    Core.lambdaParameter = (Core.Name "i"),
                                    Core.lambdaDomain = (Just (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32))),
                                    Core.lambdaBody = (Core.TermApplication (Core.Application {
                                      Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.literals.showInt32"))),
                                      Core.applicationArgument = (Core.TermVariable (Core.Name "i"))}))})))}]})))),
                            Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32))})),
                          Core.bindingType = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [],
                            Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
                              Core.functionTypeDomain = (Core.TypeApplication (Core.ApplicationType {
                                Core.applicationTypeFunction = (Core.TypeVariable TestTypes.testTypeUnionPolymorphicRecursiveName),
                                Core.applicationTypeArgument = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32))})),
                              Core.functionTypeCodomain = (Core.TypeLiteral Core.LiteralTypeString)})),
                            Core.typeSchemeConstraints = Nothing}))}],
                      Core.letBody = (Core.TermVariable (Core.Name "test"))})),
                    Testing.etaExpansionTestCaseOutput = (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "test"),
                          Core.bindingTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                            Core.lambdaParameter = (Core.Name "v1"),
                            Core.lambdaDomain = Nothing,
                            Core.lambdaBody = (Core.TermApplication (Core.Application {
                              Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm {
                                Core.typeApplicationTermBody = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
                                  Core.caseStatementTypeName = TestTypes.testTypeUnionPolymorphicRecursiveName,
                                  Core.caseStatementDefault = (Just (Core.TermLiteral (Core.LiteralString "other"))),
                                  Core.caseStatementCases = [
                                    Core.Field {
                                      Core.fieldName = (Core.Name "value"),
                                      Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                                        Core.lambdaParameter = (Core.Name "i"),
                                        Core.lambdaDomain = (Just (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32))),
                                        Core.lambdaBody = (Core.TermApplication (Core.Application {
                                          Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.literals.showInt32"))),
                                          Core.applicationArgument = (Core.TermVariable (Core.Name "i"))}))})))}]})))),
                                Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32))})),
                              Core.applicationArgument = (Core.TermVariable (Core.Name "v1"))}))}))),
                          Core.bindingType = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [],
                            Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
                              Core.functionTypeDomain = (Core.TypeApplication (Core.ApplicationType {
                                Core.applicationTypeFunction = (Core.TypeVariable TestTypes.testTypeUnionPolymorphicRecursiveName),
                                Core.applicationTypeArgument = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32))})),
                              Core.functionTypeCodomain = (Core.TypeLiteral Core.LiteralTypeString)})),
                            Core.typeSchemeConstraints = Nothing}))}],
                      Core.letBody = (Core.TermVariable (Core.Name "test"))}))})),
                  Testing.testCaseWithMetadataDescription = Nothing,
                  Testing.testCaseWithMetadataTags = []},
                Testing.TestCaseWithMetadata {
                  Testing.testCaseWithMetadataName = "applied UnionPolymorphicRecursive with int32",
                  Testing.testCaseWithMetadataCase = (Testing.TestCaseEtaExpansion (Testing.EtaExpansionTestCase {
                    Testing.etaExpansionTestCaseInput = (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "test"),
                          Core.bindingTerm = (Core.TermApplication (Core.Application {
                            Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm {
                              Core.typeApplicationTermBody = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
                                Core.caseStatementTypeName = TestTypes.testTypeUnionPolymorphicRecursiveName,
                                Core.caseStatementDefault = (Just (Core.TermLiteral (Core.LiteralString "other"))),
                                Core.caseStatementCases = [
                                  Core.Field {
                                    Core.fieldName = (Core.Name "value"),
                                    Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                                      Core.lambdaParameter = (Core.Name "i"),
                                      Core.lambdaDomain = (Just (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32))),
                                      Core.lambdaBody = (Core.TermApplication (Core.Application {
                                        Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.literals.showInt32"))),
                                        Core.applicationArgument = (Core.TermVariable (Core.Name "i"))}))})))}]})))),
                              Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32))})),
                            Core.applicationArgument = (Core.TermTypeApplication (Core.TypeApplicationTerm {
                              Core.typeApplicationTermBody = (Core.TermUnion (Core.Injection {
                                Core.injectionTypeName = TestTypes.testTypeUnionPolymorphicRecursiveName,
                                Core.injectionField = Core.Field {
                                  Core.fieldName = (Core.Name "value"),
                                  Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 42)))}})),
                              Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32))}))})),
                          Core.bindingType = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [],
                            Core.typeSchemeType = (Core.TypeLiteral Core.LiteralTypeString),
                            Core.typeSchemeConstraints = Nothing}))}],
                      Core.letBody = (Core.TermVariable (Core.Name "test"))})),
                    Testing.etaExpansionTestCaseOutput = (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "test"),
                          Core.bindingTerm = (Core.TermApplication (Core.Application {
                            Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm {
                              Core.typeApplicationTermBody = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
                                Core.caseStatementTypeName = TestTypes.testTypeUnionPolymorphicRecursiveName,
                                Core.caseStatementDefault = (Just (Core.TermLiteral (Core.LiteralString "other"))),
                                Core.caseStatementCases = [
                                  Core.Field {
                                    Core.fieldName = (Core.Name "value"),
                                    Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                                      Core.lambdaParameter = (Core.Name "i"),
                                      Core.lambdaDomain = (Just (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32))),
                                      Core.lambdaBody = (Core.TermApplication (Core.Application {
                                        Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.literals.showInt32"))),
                                        Core.applicationArgument = (Core.TermVariable (Core.Name "i"))}))})))}]})))),
                              Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32))})),
                            Core.applicationArgument = (Core.TermTypeApplication (Core.TypeApplicationTerm {
                              Core.typeApplicationTermBody = (Core.TermUnion (Core.Injection {
                                Core.injectionTypeName = TestTypes.testTypeUnionPolymorphicRecursiveName,
                                Core.injectionField = Core.Field {
                                  Core.fieldName = (Core.Name "value"),
                                  Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 42)))}})),
                              Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32))}))})),
                          Core.bindingType = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [],
                            Core.typeSchemeType = (Core.TypeLiteral Core.LiteralTypeString),
                            Core.typeSchemeConstraints = Nothing}))}],
                      Core.letBody = (Core.TermVariable (Core.Name "test"))}))})),
                  Testing.testCaseWithMetadataDescription = Nothing,
                  Testing.testCaseWithMetadataTags = []},
                Testing.TestCaseWithMetadata {
                  Testing.testCaseWithMetadataName = "applied UnionPolymorphicRecursive with int32 in lambda",
                  Testing.testCaseWithMetadataCase = (Testing.TestCaseEtaExpansion (Testing.EtaExpansionTestCase {
                    Testing.etaExpansionTestCaseInput = (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "test"),
                          Core.bindingTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                            Core.lambdaParameter = (Core.Name "x"),
                            Core.lambdaDomain = (Just (Core.TypeApplication (Core.ApplicationType {
                              Core.applicationTypeFunction = (Core.TypeVariable TestTypes.testTypeUnionPolymorphicRecursiveName),
                              Core.applicationTypeArgument = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32))}))),
                            Core.lambdaBody = (Core.TermApplication (Core.Application {
                              Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm {
                                Core.typeApplicationTermBody = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
                                  Core.caseStatementTypeName = TestTypes.testTypeUnionPolymorphicRecursiveName,
                                  Core.caseStatementDefault = (Just (Core.TermLiteral (Core.LiteralString "other"))),
                                  Core.caseStatementCases = [
                                    Core.Field {
                                      Core.fieldName = (Core.Name "value"),
                                      Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                                        Core.lambdaParameter = (Core.Name "i"),
                                        Core.lambdaDomain = (Just (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32))),
                                        Core.lambdaBody = (Core.TermApplication (Core.Application {
                                          Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.literals.showInt32"))),
                                          Core.applicationArgument = (Core.TermVariable (Core.Name "i"))}))})))}]})))),
                                Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32))})),
                              Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))),
                          Core.bindingType = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [],
                            Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
                              Core.functionTypeDomain = (Core.TypeApplication (Core.ApplicationType {
                                Core.applicationTypeFunction = (Core.TypeVariable TestTypes.testTypeUnionPolymorphicRecursiveName),
                                Core.applicationTypeArgument = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32))})),
                              Core.functionTypeCodomain = (Core.TypeLiteral Core.LiteralTypeString)})),
                            Core.typeSchemeConstraints = Nothing}))}],
                      Core.letBody = (Core.TermVariable (Core.Name "test"))})),
                    Testing.etaExpansionTestCaseOutput = (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "test"),
                          Core.bindingTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                            Core.lambdaParameter = (Core.Name "x"),
                            Core.lambdaDomain = (Just (Core.TypeApplication (Core.ApplicationType {
                              Core.applicationTypeFunction = (Core.TypeVariable TestTypes.testTypeUnionPolymorphicRecursiveName),
                              Core.applicationTypeArgument = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32))}))),
                            Core.lambdaBody = (Core.TermApplication (Core.Application {
                              Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm {
                                Core.typeApplicationTermBody = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
                                  Core.caseStatementTypeName = TestTypes.testTypeUnionPolymorphicRecursiveName,
                                  Core.caseStatementDefault = (Just (Core.TermLiteral (Core.LiteralString "other"))),
                                  Core.caseStatementCases = [
                                    Core.Field {
                                      Core.fieldName = (Core.Name "value"),
                                      Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                                        Core.lambdaParameter = (Core.Name "i"),
                                        Core.lambdaDomain = (Just (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32))),
                                        Core.lambdaBody = (Core.TermApplication (Core.Application {
                                          Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.literals.showInt32"))),
                                          Core.applicationArgument = (Core.TermVariable (Core.Name "i"))}))})))}]})))),
                                Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32))})),
                              Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))),
                          Core.bindingType = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [],
                            Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
                              Core.functionTypeDomain = (Core.TypeApplication (Core.ApplicationType {
                                Core.applicationTypeFunction = (Core.TypeVariable TestTypes.testTypeUnionPolymorphicRecursiveName),
                                Core.applicationTypeArgument = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32))})),
                              Core.functionTypeCodomain = (Core.TypeLiteral Core.LiteralTypeString)})),
                            Core.typeSchemeConstraints = Nothing}))}],
                      Core.letBody = (Core.TermVariable (Core.Name "test"))}))})),
                  Testing.testCaseWithMetadataDescription = Nothing,
                  Testing.testCaseWithMetadataTags = []},
                Testing.TestCaseWithMetadata {
                  Testing.testCaseWithMetadataName = "applied generic UnionPolymorphicRecursive in lambda",
                  Testing.testCaseWithMetadataCase = (Testing.TestCaseEtaExpansion (Testing.EtaExpansionTestCase {
                    Testing.etaExpansionTestCaseInput = (Core.TermTypeLambda (Core.TypeLambda {
                      Core.typeLambdaParameter = (Core.Name "t0"),
                      Core.typeLambdaBody = (Core.TermLet (Core.Let {
                        Core.letBindings = [
                          Core.Binding {
                            Core.bindingName = (Core.Name "test"),
                            Core.bindingTerm = (Core.TermTypeLambda (Core.TypeLambda {
                              Core.typeLambdaParameter = (Core.Name "t1"),
                              Core.typeLambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                                Core.lambdaParameter = (Core.Name "x"),
                                Core.lambdaDomain = (Just (Core.TypeApplication (Core.ApplicationType {
                                  Core.applicationTypeFunction = (Core.TypeVariable TestTypes.testTypeUnionPolymorphicRecursiveName),
                                  Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "t1"))}))),
                                Core.lambdaBody = (Core.TermApplication (Core.Application {
                                  Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm {
                                    Core.typeApplicationTermBody = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
                                      Core.caseStatementTypeName = TestTypes.testTypeUnionPolymorphicRecursiveName,
                                      Core.caseStatementDefault = (Just (Core.TermLiteral (Core.LiteralString "other"))),
                                      Core.caseStatementCases = [
                                        Core.Field {
                                          Core.fieldName = (Core.Name "value"),
                                          Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                                            Core.lambdaParameter = (Core.Name "ignored"),
                                            Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "t1"))),
                                            Core.lambdaBody = (Core.TermLiteral (Core.LiteralString "foo"))})))}]})))),
                                    Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "t1"))})),
                                  Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))})))})),
                            Core.bindingType = (Just (Core.TypeScheme {
                              Core.typeSchemeVariables = [
                                Core.Name "t1"],
                              Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
                                Core.functionTypeDomain = (Core.TypeApplication (Core.ApplicationType {
                                  Core.applicationTypeFunction = (Core.TypeVariable TestTypes.testTypeUnionPolymorphicRecursiveName),
                                  Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "t1"))})),
                                Core.functionTypeCodomain = (Core.TypeLiteral Core.LiteralTypeString)})),
                              Core.typeSchemeConstraints = Nothing}))}],
                        Core.letBody = (Core.TermTypeApplication (Core.TypeApplicationTerm {
                          Core.typeApplicationTermBody = (Core.TermVariable (Core.Name "test")),
                          Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "t0"))}))}))})),
                    Testing.etaExpansionTestCaseOutput = (Core.TermTypeLambda (Core.TypeLambda {
                      Core.typeLambdaParameter = (Core.Name "t0"),
                      Core.typeLambdaBody = (Core.TermLet (Core.Let {
                        Core.letBindings = [
                          Core.Binding {
                            Core.bindingName = (Core.Name "test"),
                            Core.bindingTerm = (Core.TermTypeLambda (Core.TypeLambda {
                              Core.typeLambdaParameter = (Core.Name "t1"),
                              Core.typeLambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                                Core.lambdaParameter = (Core.Name "x"),
                                Core.lambdaDomain = (Just (Core.TypeApplication (Core.ApplicationType {
                                  Core.applicationTypeFunction = (Core.TypeVariable TestTypes.testTypeUnionPolymorphicRecursiveName),
                                  Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "t1"))}))),
                                Core.lambdaBody = (Core.TermApplication (Core.Application {
                                  Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm {
                                    Core.typeApplicationTermBody = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
                                      Core.caseStatementTypeName = TestTypes.testTypeUnionPolymorphicRecursiveName,
                                      Core.caseStatementDefault = (Just (Core.TermLiteral (Core.LiteralString "other"))),
                                      Core.caseStatementCases = [
                                        Core.Field {
                                          Core.fieldName = (Core.Name "value"),
                                          Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                                            Core.lambdaParameter = (Core.Name "ignored"),
                                            Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "t1"))),
                                            Core.lambdaBody = (Core.TermLiteral (Core.LiteralString "foo"))})))}]})))),
                                    Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "t1"))})),
                                  Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))})))})),
                            Core.bindingType = (Just (Core.TypeScheme {
                              Core.typeSchemeVariables = [
                                Core.Name "t1"],
                              Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
                                Core.functionTypeDomain = (Core.TypeApplication (Core.ApplicationType {
                                  Core.applicationTypeFunction = (Core.TypeVariable TestTypes.testTypeUnionPolymorphicRecursiveName),
                                  Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "t1"))})),
                                Core.functionTypeCodomain = (Core.TypeLiteral Core.LiteralTypeString)})),
                              Core.typeSchemeConstraints = Nothing}))}],
                        Core.letBody = (Core.TermTypeApplication (Core.TypeApplicationTerm {
                          Core.typeApplicationTermBody = (Core.TermVariable (Core.Name "test")),
                          Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "t0"))}))}))}))})),
                  Testing.testCaseWithMetadataDescription = Nothing,
                  Testing.testCaseWithMetadataTags = []}]},
            Testing.TestGroup {
              Testing.testGroupName = "Forced expansion in case statement branches",
              Testing.testGroupDescription = Nothing,
              Testing.testGroupSubgroups = [],
              Testing.testGroupCases = [
                Testing.TestCaseWithMetadata {
                  Testing.testCaseWithMetadataName = "variable reference in case branch is expanded",
                  Testing.testCaseWithMetadataCase = (Testing.TestCaseEtaExpansion (Testing.EtaExpansionTestCase {
                    Testing.etaExpansionTestCaseInput = (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "handler"),
                          Core.bindingTerm = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.toLower"))),
                          Core.bindingType = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [],
                            Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
                              Core.functionTypeDomain = (Core.TypeLiteral Core.LiteralTypeString),
                              Core.functionTypeCodomain = (Core.TypeLiteral Core.LiteralTypeString)})),
                            Core.typeSchemeConstraints = Nothing}))}],
                      Core.letBody = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
                        Core.caseStatementTypeName = TestTypes.testTypeUnionMonomorphicName,
                        Core.caseStatementDefault = Nothing,
                        Core.caseStatementCases = [
                          Core.Field {
                            Core.fieldName = (Core.Name "bool"),
                            Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                              Core.lambdaParameter = (Core.Name "ignored"),
                              Core.lambdaDomain = Nothing,
                              Core.lambdaBody = (Core.TermLiteral (Core.LiteralString "boolean value"))})))},
                          Core.Field {
                            Core.fieldName = (Core.Name "string"),
                            Core.fieldTerm = (Core.TermVariable (Core.Name "handler"))},
                          Core.Field {
                            Core.fieldName = (Core.Name "unit"),
                            Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                              Core.lambdaParameter = (Core.Name "ignored"),
                              Core.lambdaDomain = Nothing,
                              Core.lambdaBody = (Core.TermLiteral (Core.LiteralString "unit value"))})))}]}))))})),
                    Testing.etaExpansionTestCaseOutput = (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "handler"),
                          Core.bindingTerm = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.toLower"))),
                          Core.bindingType = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [],
                            Core.typeSchemeType = (Core.TypeFunction (Core.FunctionType {
                              Core.functionTypeDomain = (Core.TypeLiteral Core.LiteralTypeString),
                              Core.functionTypeCodomain = (Core.TypeLiteral Core.LiteralTypeString)})),
                            Core.typeSchemeConstraints = Nothing}))}],
                      Core.letBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                        Core.lambdaParameter = (Core.Name "v1"),
                        Core.lambdaDomain = Nothing,
                        Core.lambdaBody = (Core.TermApplication (Core.Application {
                          Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
                            Core.caseStatementTypeName = TestTypes.testTypeUnionMonomorphicName,
                            Core.caseStatementDefault = Nothing,
                            Core.caseStatementCases = [
                              Core.Field {
                                Core.fieldName = (Core.Name "bool"),
                                Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                                  Core.lambdaParameter = (Core.Name "ignored"),
                                  Core.lambdaDomain = Nothing,
                                  Core.lambdaBody = (Core.TermLiteral (Core.LiteralString "boolean value"))})))},
                              Core.Field {
                                Core.fieldName = (Core.Name "string"),
                                Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                                  Core.lambdaParameter = (Core.Name "v1"),
                                  Core.lambdaDomain = Nothing,
                                  Core.lambdaBody = (Core.TermApplication (Core.Application {
                                    Core.applicationFunction = (Core.TermVariable (Core.Name "handler")),
                                    Core.applicationArgument = (Core.TermVariable (Core.Name "v1"))}))})))},
                              Core.Field {
                                Core.fieldName = (Core.Name "unit"),
                                Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                                  Core.lambdaParameter = (Core.Name "ignored"),
                                  Core.lambdaDomain = Nothing,
                                  Core.lambdaBody = (Core.TermLiteral (Core.LiteralString "unit value"))})))}]})))),
                          Core.applicationArgument = (Core.TermVariable (Core.Name "v1"))}))})))}))})),
                  Testing.testCaseWithMetadataDescription = Nothing,
                  Testing.testCaseWithMetadataTags = []},
                Testing.TestCaseWithMetadata {
                  Testing.testCaseWithMetadataName = "bare primitive in case branch is expanded",
                  Testing.testCaseWithMetadataCase = (Testing.TestCaseEtaExpansion (Testing.EtaExpansionTestCase {
                    Testing.etaExpansionTestCaseInput = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
                      Core.caseStatementTypeName = TestTypes.testTypeUnionMonomorphicName,
                      Core.caseStatementDefault = Nothing,
                      Core.caseStatementCases = [
                        Core.Field {
                          Core.fieldName = (Core.Name "bool"),
                          Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                            Core.lambdaParameter = (Core.Name "ignored"),
                            Core.lambdaDomain = Nothing,
                            Core.lambdaBody = (Core.TermLiteral (Core.LiteralString "boolean value"))})))},
                        Core.Field {
                          Core.fieldName = (Core.Name "string"),
                          Core.fieldTerm = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.toLower")))},
                        Core.Field {
                          Core.fieldName = (Core.Name "unit"),
                          Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                            Core.lambdaParameter = (Core.Name "ignored"),
                            Core.lambdaDomain = Nothing,
                            Core.lambdaBody = (Core.TermLiteral (Core.LiteralString "unit value"))})))}]})))),
                    Testing.etaExpansionTestCaseOutput = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                      Core.lambdaParameter = (Core.Name "v1"),
                      Core.lambdaDomain = Nothing,
                      Core.lambdaBody = (Core.TermApplication (Core.Application {
                        Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
                          Core.caseStatementTypeName = TestTypes.testTypeUnionMonomorphicName,
                          Core.caseStatementDefault = Nothing,
                          Core.caseStatementCases = [
                            Core.Field {
                              Core.fieldName = (Core.Name "bool"),
                              Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                                Core.lambdaParameter = (Core.Name "ignored"),
                                Core.lambdaDomain = Nothing,
                                Core.lambdaBody = (Core.TermLiteral (Core.LiteralString "boolean value"))})))},
                            Core.Field {
                              Core.fieldName = (Core.Name "string"),
                              Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                                Core.lambdaParameter = (Core.Name "v1"),
                                Core.lambdaDomain = Nothing,
                                Core.lambdaBody = (Core.TermApplication (Core.Application {
                                  Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.toLower"))),
                                  Core.applicationArgument = (Core.TermVariable (Core.Name "v1"))}))})))},
                            Core.Field {
                              Core.fieldName = (Core.Name "unit"),
                              Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                                Core.lambdaParameter = (Core.Name "ignored"),
                                Core.lambdaDomain = Nothing,
                                Core.lambdaBody = (Core.TermLiteral (Core.LiteralString "unit value"))})))}]})))),
                        Core.applicationArgument = (Core.TermVariable (Core.Name "v1"))}))})))})),
                  Testing.testCaseWithMetadataDescription = Nothing,
                  Testing.testCaseWithMetadataTags = []},
                Testing.TestCaseWithMetadata {
                  Testing.testCaseWithMetadataName = "variable reference outside case branch is not expanded",
                  Testing.testCaseWithMetadataCase = (Testing.TestCaseEtaExpansion (Testing.EtaExpansionTestCase {
                    Testing.etaExpansionTestCaseInput = (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "handler"),
                          Core.bindingTerm = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.toLower"))),
                          Core.bindingType = Nothing}],
                      Core.letBody = (Core.TermVariable (Core.Name "handler"))})),
                    Testing.etaExpansionTestCaseOutput = (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "handler"),
                          Core.bindingTerm = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.toLower"))),
                          Core.bindingType = Nothing}],
                      Core.letBody = (Core.TermVariable (Core.Name "handler"))}))})),
                  Testing.testCaseWithMetadataDescription = Nothing,
                  Testing.testCaseWithMetadataTags = []},
                Testing.TestCaseWithMetadata {
                  Testing.testCaseWithMetadataName = "bare primitive outside case branch is not expanded",
                  Testing.testCaseWithMetadataCase = (Testing.TestCaseEtaExpansion (Testing.EtaExpansionTestCase {
                    Testing.etaExpansionTestCaseInput = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.toLower"))),
                    Testing.etaExpansionTestCaseOutput = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.toLower")))})),
                  Testing.testCaseWithMetadataDescription = Nothing,
                  Testing.testCaseWithMetadataTags = []}]}],
          Testing.testGroupCases = []},
        Testing.TestGroup {
          Testing.testGroupName = "Non-expansion of eliminations which produce functions",
          Testing.testGroupDescription = Nothing,
          Testing.testGroupSubgroups = [],
          Testing.testGroupCases = [
            Testing.TestCaseWithMetadata {
              Testing.testCaseWithMetadataName = "applied case statement",
              Testing.testCaseWithMetadataCase = (Testing.TestCaseEtaExpansion (Testing.EtaExpansionTestCase {
                Testing.etaExpansionTestCaseInput = (Core.TermTypeLambda (Core.TypeLambda {
                  Core.typeLambdaParameter = (Core.Name "t0"),
                  Core.typeLambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                    Core.lambdaParameter = (Core.Name "dir"),
                    Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.coders.CoderDirection"))),
                    Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                      Core.lambdaParameter = (Core.Name "coder"),
                      Core.lambdaDomain = (Just (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 "t0"))})),
                        Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "t0"))}))),
                      Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                        Core.lambdaParameter = (Core.Name "cx"),
                        Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.context.Context"))),
                        Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                          Core.lambdaParameter = (Core.Name "v1"),
                          Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "t0"))),
                          Core.lambdaBody = (Core.TermApplication (Core.Application {
                            Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
                              Core.caseStatementTypeName = (Core.Name "hydra.coders.CoderDirection"),
                              Core.caseStatementDefault = Nothing,
                              Core.caseStatementCases = [
                                Core.Field {
                                  Core.fieldName = (Core.Name "encode"),
                                  Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                                    Core.lambdaParameter = (Core.Name "_"),
                                    Core.lambdaDomain = (Just Core.TypeUnit),
                                    Core.lambdaBody = (Core.TermApplication (Core.Application {
                                      Core.applicationFunction = (Core.TermApplication (Core.Application {
                                        Core.applicationFunction = (Core.TermApplication (Core.Application {
                                          Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm {
                                            Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm {
                                              Core.typeApplicationTermBody = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection {
                                                Core.projectionTypeName = (Core.Name "hydra.util.Coder"),
                                                Core.projectionField = (Core.Name "encode")})))),
                                              Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "t0"))})),
                                            Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "t0"))})),
                                          Core.applicationArgument = (Core.TermVariable (Core.Name "coder"))})),
                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
                                      Core.applicationArgument = (Core.TermVariable (Core.Name "v1"))}))})))},
                                Core.Field {
                                  Core.fieldName = (Core.Name "decode"),
                                  Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                                    Core.lambdaParameter = (Core.Name "_"),
                                    Core.lambdaDomain = (Just Core.TypeUnit),
                                    Core.lambdaBody = (Core.TermApplication (Core.Application {
                                      Core.applicationFunction = (Core.TermApplication (Core.Application {
                                        Core.applicationFunction = (Core.TermApplication (Core.Application {
                                          Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm {
                                            Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm {
                                              Core.typeApplicationTermBody = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection {
                                                Core.projectionTypeName = (Core.Name "hydra.util.Coder"),
                                                Core.projectionField = (Core.Name "decode")})))),
                                              Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "t0"))})),
                                            Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "t0"))})),
                                          Core.applicationArgument = (Core.TermVariable (Core.Name "coder"))})),
                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
                                      Core.applicationArgument = (Core.TermVariable (Core.Name "v1"))}))})))}]})))),
                            Core.applicationArgument = (Core.TermVariable (Core.Name "dir"))}))})))})))})))})))})),
                Testing.etaExpansionTestCaseOutput = (Core.TermTypeLambda (Core.TypeLambda {
                  Core.typeLambdaParameter = (Core.Name "t0"),
                  Core.typeLambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                    Core.lambdaParameter = (Core.Name "dir"),
                    Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.coders.CoderDirection"))),
                    Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                      Core.lambdaParameter = (Core.Name "coder"),
                      Core.lambdaDomain = (Just (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 "t0"))})),
                        Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "t0"))}))),
                      Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                        Core.lambdaParameter = (Core.Name "cx"),
                        Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.context.Context"))),
                        Core.lambdaBody = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                          Core.lambdaParameter = (Core.Name "v1"),
                          Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "t0"))),
                          Core.lambdaBody = (Core.TermApplication (Core.Application {
                            Core.applicationFunction = (Core.TermFunction (Core.FunctionElimination (Core.EliminationUnion (Core.CaseStatement {
                              Core.caseStatementTypeName = (Core.Name "hydra.coders.CoderDirection"),
                              Core.caseStatementDefault = Nothing,
                              Core.caseStatementCases = [
                                Core.Field {
                                  Core.fieldName = (Core.Name "encode"),
                                  Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                                    Core.lambdaParameter = (Core.Name "_"),
                                    Core.lambdaDomain = (Just Core.TypeUnit),
                                    Core.lambdaBody = (Core.TermApplication (Core.Application {
                                      Core.applicationFunction = (Core.TermApplication (Core.Application {
                                        Core.applicationFunction = (Core.TermApplication (Core.Application {
                                          Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm {
                                            Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm {
                                              Core.typeApplicationTermBody = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection {
                                                Core.projectionTypeName = (Core.Name "hydra.util.Coder"),
                                                Core.projectionField = (Core.Name "encode")})))),
                                              Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "t0"))})),
                                            Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "t0"))})),
                                          Core.applicationArgument = (Core.TermVariable (Core.Name "coder"))})),
                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
                                      Core.applicationArgument = (Core.TermVariable (Core.Name "v1"))}))})))},
                                Core.Field {
                                  Core.fieldName = (Core.Name "decode"),
                                  Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                                    Core.lambdaParameter = (Core.Name "_"),
                                    Core.lambdaDomain = (Just Core.TypeUnit),
                                    Core.lambdaBody = (Core.TermApplication (Core.Application {
                                      Core.applicationFunction = (Core.TermApplication (Core.Application {
                                        Core.applicationFunction = (Core.TermApplication (Core.Application {
                                          Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm {
                                            Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm {
                                              Core.typeApplicationTermBody = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection {
                                                Core.projectionTypeName = (Core.Name "hydra.util.Coder"),
                                                Core.projectionField = (Core.Name "decode")})))),
                                              Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "t0"))})),
                                            Core.typeApplicationTermType = (Core.TypeVariable (Core.Name "t0"))})),
                                          Core.applicationArgument = (Core.TermVariable (Core.Name "coder"))})),
                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),
                                      Core.applicationArgument = (Core.TermVariable (Core.Name "v1"))}))})))}]})))),
                            Core.applicationArgument = (Core.TermVariable (Core.Name "dir"))}))})))})))})))})))}))})),
              Testing.testCaseWithMetadataDescription = Nothing,
              Testing.testCaseWithMetadataTags = []},
            Testing.TestCaseWithMetadata {
              Testing.testCaseWithMetadataName = "applied projection",
              Testing.testCaseWithMetadataCase = (Testing.TestCaseEtaExpansion (Testing.EtaExpansionTestCase {
                Testing.etaExpansionTestCaseInput = (Core.TermApplication (Core.Application {
                  Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm {
                    Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm {
                      Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm {
                        Core.typeApplicationTermBody = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection {
                          Core.projectionTypeName = TestTypes.testTypeTripleName,
                          Core.projectionField = (Core.Name "third")})))),
                        Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32))})),
                      Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32))})),
                    Core.typeApplicationTermType = (Core.TypeFunction (Core.FunctionType {
                      Core.functionTypeDomain = (Core.TypeLiteral Core.LiteralTypeString),
                      Core.functionTypeCodomain = (Core.TypeLiteral Core.LiteralTypeString)}))})),
                  Core.applicationArgument = (Core.TermRecord (Core.Record {
                    Core.recordTypeName = TestTypes.testTypeTripleName,
                    Core.recordFields = [
                      Core.Field {
                        Core.fieldName = (Core.Name "first"),
                        Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 42)))},
                      Core.Field {
                        Core.fieldName = (Core.Name "second"),
                        Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 137)))},
                      Core.Field {
                        Core.fieldName = (Core.Name "third"),
                        Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                          Core.lambdaParameter = (Core.Name "s"),
                          Core.lambdaDomain = Nothing,
                          Core.lambdaBody = (Core.TermApplication (Core.Application {
                            Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.toLower"))),
                            Core.applicationArgument = (Core.TermVariable (Core.Name "s"))}))})))}]}))})),
                Testing.etaExpansionTestCaseOutput = (Core.TermApplication (Core.Application {
                  Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm {
                    Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm {
                      Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm {
                        Core.typeApplicationTermBody = (Core.TermFunction (Core.FunctionElimination (Core.EliminationRecord (Core.Projection {
                          Core.projectionTypeName = TestTypes.testTypeTripleName,
                          Core.projectionField = (Core.Name "third")})))),
                        Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32))})),
                      Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32))})),
                    Core.typeApplicationTermType = (Core.TypeFunction (Core.FunctionType {
                      Core.functionTypeDomain = (Core.TypeLiteral Core.LiteralTypeString),
                      Core.functionTypeCodomain = (Core.TypeLiteral Core.LiteralTypeString)}))})),
                  Core.applicationArgument = (Core.TermRecord (Core.Record {
                    Core.recordTypeName = TestTypes.testTypeTripleName,
                    Core.recordFields = [
                      Core.Field {
                        Core.fieldName = (Core.Name "first"),
                        Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 42)))},
                      Core.Field {
                        Core.fieldName = (Core.Name "second"),
                        Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 137)))},
                      Core.Field {
                        Core.fieldName = (Core.Name "third"),
                        Core.fieldTerm = (Core.TermFunction (Core.FunctionLambda (Core.Lambda {
                          Core.lambdaParameter = (Core.Name "s"),
                          Core.lambdaDomain = Nothing,
                          Core.lambdaBody = (Core.TermApplication (Core.Application {
                            Core.applicationFunction = (Core.TermFunction (Core.FunctionPrimitive (Core.Name "hydra.lib.strings.toLower"))),
                            Core.applicationArgument = (Core.TermVariable (Core.Name "s"))}))})))}]}))}))})),
              Testing.testCaseWithMetadataDescription = Nothing,
              Testing.testCaseWithMetadataTags = []}]}],
      Testing.testGroupCases = []}