hydra-0.15.0: src/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.Lib.Eithers as Eithers
import qualified Hydra.Lib.Strings as Strings
import qualified Hydra.Reduction as Reduction
import qualified Hydra.Show.Core as ShowCore
import qualified Hydra.Test.TestGraph as TestGraph
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.Scientific as Sci
-- | 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.TestCaseUniversal (Testing.UniversalTestCase {
                    Testing.universalTestCaseActual = (Eithers.either (\e -> Strings.cat2 "ETA ERROR: " "failed") (\result -> ShowCore.term result) (Reduction.etaExpandTypedTerm TestGraph.testContext TestGraph.testGraph (Core.TermVariable (Core.Name "hydra.lib.strings.toLower")))),
                    Testing.universalTestCaseExpected = (ShowCore.term (Core.TermVariable (Core.Name "hydra.lib.strings.toLower")))})),
                  Testing.testCaseWithMetadataDescription = Nothing,
                  Testing.testCaseWithMetadataTags = []},
                Testing.TestCaseWithMetadata {
                  Testing.testCaseWithMetadataName = "binary primitive",
                  Testing.testCaseWithMetadataCase = (Testing.TestCaseUniversal (Testing.UniversalTestCase {
                    Testing.universalTestCaseActual = (Eithers.either (\e -> Strings.cat2 "ETA ERROR: " "failed") (\result -> ShowCore.term result) (Reduction.etaExpandTypedTerm TestGraph.testContext TestGraph.testGraph (Core.TermVariable (Core.Name "hydra.lib.strings.splitOn")))),
                    Testing.universalTestCaseExpected = (ShowCore.term (Core.TermVariable (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.TestCaseUniversal (Testing.UniversalTestCase {
                    Testing.universalTestCaseActual = (Eithers.either (\e -> Strings.cat2 "ETA ERROR: " "failed") (\result -> ShowCore.term result) (Reduction.etaExpandTypedTerm TestGraph.testContext TestGraph.testGraph (Core.TermApplication (Core.Application {
                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.splitOn")),
                      Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "foo"))})))),
                    Testing.universalTestCaseExpected = (ShowCore.term (Core.TermLambda (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.TermVariable (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.TestCaseUniversal (Testing.UniversalTestCase {
                    Testing.universalTestCaseActual = (Eithers.either (\e -> Strings.cat2 "ETA ERROR: " "failed") (\result -> ShowCore.term result) (Reduction.etaExpandTypedTerm TestGraph.testContext TestGraph.testGraph (Core.TermApplication (Core.Application {
                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.foldl")),
                      Core.applicationArgument = (Core.TermVariable (Core.Name "f"))})))),
                    Testing.universalTestCaseExpected = (ShowCore.term (Core.TermLambda (Core.Lambda {
                      Core.lambdaParameter = (Core.Name "v1"),
                      Core.lambdaDomain = Nothing,
                      Core.lambdaBody = (Core.TermLambda (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 "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.TestCaseUniversal (Testing.UniversalTestCase {
                    Testing.universalTestCaseActual = (Eithers.either (\e -> Strings.cat2 "ETA ERROR: " "failed") (\result -> ShowCore.term result) (Reduction.etaExpandTypedTerm TestGraph.testContext TestGraph.testGraph (Core.TermApplication (Core.Application {
                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.toLower")),
                      Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "FOO"))})))),
                    Testing.universalTestCaseExpected = (ShowCore.term (Core.TermApplication (Core.Application {
                      Core.applicationFunction = (Core.TermVariable (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.TestCaseUniversal (Testing.UniversalTestCase {
                    Testing.universalTestCaseActual = (Eithers.either (\e -> Strings.cat2 "ETA ERROR: " "failed") (\result -> ShowCore.term result) (Reduction.etaExpandTypedTerm TestGraph.testContext TestGraph.testGraph (Core.TermApplication (Core.Application {
                      Core.applicationFunction = (Core.TermApplication (Core.Application {
                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.splitOn")),
                        Core.applicationArgument = (Core.TermLiteral (Core.LiteralString ","))})),
                      Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "a,b,c"))})))),
                    Testing.universalTestCaseExpected = (ShowCore.term (Core.TermApplication (Core.Application {
                      Core.applicationFunction = (Core.TermApplication (Core.Application {
                        Core.applicationFunction = (Core.TermVariable (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.TestCaseUniversal (Testing.UniversalTestCase {
                        Testing.universalTestCaseActual = (Eithers.either (\e -> Strings.cat2 "ETA ERROR: " "failed") (\result -> ShowCore.term result) (Reduction.etaExpandTypedTerm TestGraph.testContext TestGraph.testGraph (Core.TermProject (Core.Projection {
                          Core.projectionTypeName = TestTypes.testTypePersonName,
                          Core.projectionField = (Core.Name "firstName")})))),
                        Testing.universalTestCaseExpected = (ShowCore.term (Core.TermLambda (Core.Lambda {
                          Core.lambdaParameter = (Core.Name "v1"),
                          Core.lambdaDomain = Nothing,
                          Core.lambdaBody = (Core.TermApplication (Core.Application {
                            Core.applicationFunction = (Core.TermProject (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.TestCaseUniversal (Testing.UniversalTestCase {
                        Testing.universalTestCaseActual = (Eithers.either (\e -> Strings.cat2 "ETA ERROR: " "failed") (\result -> ShowCore.term result) (Reduction.etaExpandTypedTerm TestGraph.testContext TestGraph.testGraph (Core.TermApplication (Core.Application {
                          Core.applicationFunction = (Core.TermProject (Core.Projection {
                            Core.projectionTypeName = TestTypes.testTypePersonName,
                            Core.projectionField = (Core.Name "firstName")})),
                          Core.applicationArgument = (Core.TermVariable (Core.Name "person"))})))),
                        Testing.universalTestCaseExpected = (ShowCore.term (Core.TermApplication (Core.Application {
                          Core.applicationFunction = (Core.TermProject (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.TestCaseUniversal (Testing.UniversalTestCase {
                        Testing.universalTestCaseActual = (Eithers.either (\e -> Strings.cat2 "ETA ERROR: " "failed") (\result -> ShowCore.term result) (Reduction.etaExpandTypedTerm TestGraph.testContext TestGraph.testGraph (Core.TermApplication (Core.Application {
                          Core.applicationFunction = (Core.TermProject (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.universalTestCaseExpected = (ShowCore.term (Core.TermApplication (Core.Application {
                          Core.applicationFunction = (Core.TermProject (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.TestCaseUniversal (Testing.UniversalTestCase {
                        Testing.universalTestCaseActual = (Eithers.either (\e -> Strings.cat2 "ETA ERROR: " "failed") (\result -> ShowCore.term result) (Reduction.etaExpandTypedTerm TestGraph.testContext TestGraph.testGraph (Core.TermList [
                          Core.TermProject (Core.Projection {
                            Core.projectionTypeName = TestTypes.testTypePersonName,
                            Core.projectionField = (Core.Name "firstName")}),
                          (Core.TermVariable (Core.Name "hydra.lib.strings.toLower"))]))),
                        Testing.universalTestCaseExpected = (ShowCore.term (Core.TermList [
                          Core.TermLambda (Core.Lambda {
                            Core.lambdaParameter = (Core.Name "v1"),
                            Core.lambdaDomain = Nothing,
                            Core.lambdaBody = (Core.TermApplication (Core.Application {
                              Core.applicationFunction = (Core.TermProject (Core.Projection {
                                Core.projectionTypeName = TestTypes.testTypePersonName,
                                Core.projectionField = (Core.Name "firstName")})),
                              Core.applicationArgument = (Core.TermVariable (Core.Name "v1"))}))}),
                          (Core.TermVariable (Core.Name "hydra.lib.strings.toLower"))]))})),
                      Testing.testCaseWithMetadataDescription = Nothing,
                      Testing.testCaseWithMetadataTags = []},
                    Testing.TestCaseWithMetadata {
                      Testing.testCaseWithMetadataName = "projection in a tuple",
                      Testing.testCaseWithMetadataCase = (Testing.TestCaseUniversal (Testing.UniversalTestCase {
                        Testing.universalTestCaseActual = (Eithers.either (\e -> Strings.cat2 "ETA ERROR: " "failed") (\result -> ShowCore.term result) (Reduction.etaExpandTypedTerm TestGraph.testContext TestGraph.testGraph (Core.TermPair (Core.TermProject (Core.Projection {
                          Core.projectionTypeName = TestTypes.testTypePersonName,
                          Core.projectionField = (Core.Name "firstName")}), (Core.TermLiteral (Core.LiteralString "default")))))),
                        Testing.universalTestCaseExpected = (ShowCore.term (Core.TermPair (Core.TermLambda (Core.Lambda {
                          Core.lambdaParameter = (Core.Name "v1"),
                          Core.lambdaDomain = Nothing,
                          Core.lambdaBody = (Core.TermApplication (Core.Application {
                            Core.applicationFunction = (Core.TermProject (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.TestCaseUniversal (Testing.UniversalTestCase {
                        Testing.universalTestCaseActual = (Eithers.either (\e -> Strings.cat2 "ETA ERROR: " "failed") (\result -> ShowCore.term result) (Reduction.etaExpandTypedTerm TestGraph.testContext TestGraph.testGraph (Core.TermLet (Core.Let {
                          Core.letBindings = [
                            Core.Binding {
                              Core.bindingName = (Core.Name "getter"),
                              Core.bindingTerm = (Core.TermProject (Core.Projection {
                                Core.projectionTypeName = TestTypes.testTypePersonName,
                                Core.projectionField = (Core.Name "firstName")})),
                              Core.bindingTypeScheme = Nothing}],
                          Core.letBody = (Core.TermVariable (Core.Name "getter"))})))),
                        Testing.universalTestCaseExpected = (ShowCore.term (Core.TermLet (Core.Let {
                          Core.letBindings = [
                            Core.Binding {
                              Core.bindingName = (Core.Name "getter"),
                              Core.bindingTerm = (Core.TermLambda (Core.Lambda {
                                Core.lambdaParameter = (Core.Name "v1"),
                                Core.lambdaDomain = Nothing,
                                Core.lambdaBody = (Core.TermApplication (Core.Application {
                                  Core.applicationFunction = (Core.TermProject (Core.Projection {
                                    Core.projectionTypeName = TestTypes.testTypePersonName,
                                    Core.projectionField = (Core.Name "firstName")})),
                                  Core.applicationArgument = (Core.TermVariable (Core.Name "v1"))}))})),
                              Core.bindingTypeScheme = Nothing}],
                          Core.letBody = (Core.TermVariable (Core.Name "getter"))})))})),
                      Testing.testCaseWithMetadataDescription = Nothing,
                      Testing.testCaseWithMetadataTags = []},
                    Testing.TestCaseWithMetadata {
                      Testing.testCaseWithMetadataName = "projection in lambda body",
                      Testing.testCaseWithMetadataCase = (Testing.TestCaseUniversal (Testing.UniversalTestCase {
                        Testing.universalTestCaseActual = (Eithers.either (\e -> Strings.cat2 "ETA ERROR: " "failed") (\result -> ShowCore.term result) (Reduction.etaExpandTypedTerm TestGraph.testContext TestGraph.testGraph (Core.TermLambda (Core.Lambda {
                          Core.lambdaParameter = (Core.Name "x"),
                          Core.lambdaDomain = Nothing,
                          Core.lambdaBody = (Core.TermProject (Core.Projection {
                            Core.projectionTypeName = TestTypes.testTypePersonName,
                            Core.projectionField = (Core.Name "firstName")}))})))),
                        Testing.universalTestCaseExpected = (ShowCore.term (Core.TermLambda (Core.Lambda {
                          Core.lambdaParameter = (Core.Name "x"),
                          Core.lambdaDomain = Nothing,
                          Core.lambdaBody = (Core.TermLambda (Core.Lambda {
                            Core.lambdaParameter = (Core.Name "v1"),
                            Core.lambdaDomain = Nothing,
                            Core.lambdaBody = (Core.TermApplication (Core.Application {
                              Core.applicationFunction = (Core.TermProject (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.TestCaseUniversal (Testing.UniversalTestCase {
                        Testing.universalTestCaseActual = (Eithers.either (\e -> Strings.cat2 "ETA ERROR: " "failed") (\result -> ShowCore.term result) (Reduction.etaExpandTypedTerm TestGraph.testContext TestGraph.testGraph (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.TermProject (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.TermVariable (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.universalTestCaseExpected = (ShowCore.term (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.TermProject (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.TermVariable (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.TestCaseUniversal (Testing.UniversalTestCase {
                    Testing.universalTestCaseActual = (Eithers.either (\e -> Strings.cat2 "ETA ERROR: " "failed") (\result -> ShowCore.term result) (Reduction.etaExpandTypedTerm TestGraph.testContext TestGraph.testGraph (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.TermLambda (Core.Lambda {
                              Core.lambdaParameter = (Core.Name "x"),
                              Core.lambdaDomain = Nothing,
                              Core.lambdaBody = (Core.TermVariable (Core.Name "x"))}))})),
                          Core.bindingTypeScheme = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [
                              Core.Name "a"],
                            Core.typeSchemeBody = (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.universalTestCaseExpected = (ShowCore.term (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.TermLambda (Core.Lambda {
                              Core.lambdaParameter = (Core.Name "x"),
                              Core.lambdaDomain = Nothing,
                              Core.lambdaBody = (Core.TermVariable (Core.Name "x"))}))})),
                          Core.bindingTypeScheme = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [
                              Core.Name "a"],
                            Core.typeSchemeBody = (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.TestCaseUniversal (Testing.UniversalTestCase {
                    Testing.universalTestCaseActual = (Eithers.either (\e -> Strings.cat2 "ETA ERROR: " "failed") (\result -> ShowCore.term result) (Reduction.etaExpandTypedTerm TestGraph.testContext TestGraph.testGraph (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "partial"),
                          Core.bindingTerm = (Core.TermApplication (Core.Application {
                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.splitOn")),
                            Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "foo"))})),
                          Core.bindingTypeScheme = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [],
                            Core.typeSchemeBody = (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.universalTestCaseExpected = (ShowCore.term (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "partial"),
                          Core.bindingTerm = (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.strings.splitOn")),
                                Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "foo"))})),
                              Core.applicationArgument = (Core.TermVariable (Core.Name "v1"))}))})),
                          Core.bindingTypeScheme = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [],
                            Core.typeSchemeBody = (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.TestCaseUniversal (Testing.UniversalTestCase {
                    Testing.universalTestCaseActual = (Eithers.either (\e -> Strings.cat2 "ETA ERROR: " "failed") (\result -> ShowCore.term result) (Reduction.etaExpandTypedTerm TestGraph.testContext TestGraph.testGraph (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "getter"),
                          Core.bindingTerm = (Core.TermProject (Core.Projection {
                            Core.projectionTypeName = TestTypes.testTypePersonName,
                            Core.projectionField = (Core.Name "firstName")})),
                          Core.bindingTypeScheme = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [],
                            Core.typeSchemeBody = (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.universalTestCaseExpected = (ShowCore.term (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "getter"),
                          Core.bindingTerm = (Core.TermLambda (Core.Lambda {
                            Core.lambdaParameter = (Core.Name "v1"),
                            Core.lambdaDomain = Nothing,
                            Core.lambdaBody = (Core.TermApplication (Core.Application {
                              Core.applicationFunction = (Core.TermProject (Core.Projection {
                                Core.projectionTypeName = TestTypes.testTypePersonName,
                                Core.projectionField = (Core.Name "firstName")})),
                              Core.applicationArgument = (Core.TermVariable (Core.Name "v1"))}))})),
                          Core.bindingTypeScheme = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [],
                            Core.typeSchemeBody = (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.TestCaseUniversal (Testing.UniversalTestCase {
                    Testing.universalTestCaseActual = (Eithers.either (\e -> Strings.cat2 "ETA ERROR: " "failed") (\result -> ShowCore.term result) (Reduction.etaExpandTypedTerm TestGraph.testContext TestGraph.testGraph (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.TermLambda (Core.Lambda {
                              Core.lambdaParameter = (Core.Name "x"),
                              Core.lambdaDomain = Nothing,
                              Core.lambdaBody = (Core.TermVariable (Core.Name "x"))}))})),
                          Core.bindingTypeScheme = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [
                              Core.Name "a"],
                            Core.typeSchemeBody = (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.universalTestCaseExpected = (ShowCore.term (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.TermLambda (Core.Lambda {
                              Core.lambdaParameter = (Core.Name "x"),
                              Core.lambdaDomain = Nothing,
                              Core.lambdaBody = (Core.TermVariable (Core.Name "x"))}))})),
                          Core.bindingTypeScheme = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [
                              Core.Name "a"],
                            Core.typeSchemeBody = (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.TestCaseUniversal (Testing.UniversalTestCase {
                    Testing.universalTestCaseActual = (Eithers.either (\e -> Strings.cat2 "ETA ERROR: " "failed") (\result -> ShowCore.term result) (Reduction.etaExpandTypedTerm TestGraph.testContext TestGraph.testGraph (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.TermLambda (Core.Lambda {
                              Core.lambdaParameter = (Core.Name "x"),
                              Core.lambdaDomain = Nothing,
                              Core.lambdaBody = (Core.TermVariable (Core.Name "x"))}))})),
                          Core.bindingTypeScheme = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [
                              Core.Name "a"],
                            Core.typeSchemeBody = (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.TermVariable (Core.Name "hydra.lib.strings.splitOn"))}))})))),
                    Testing.universalTestCaseExpected = (ShowCore.term (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.TermLambda (Core.Lambda {
                              Core.lambdaParameter = (Core.Name "x"),
                              Core.lambdaDomain = Nothing,
                              Core.lambdaBody = (Core.TermVariable (Core.Name "x"))}))})),
                          Core.bindingTypeScheme = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [
                              Core.Name "a"],
                            Core.typeSchemeBody = (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.TermVariable (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.TestCaseUniversal (Testing.UniversalTestCase {
                    Testing.universalTestCaseActual = (Eithers.either (\e -> Strings.cat2 "ETA ERROR: " "failed") (\result -> ShowCore.term result) (Reduction.etaExpandTypedTerm TestGraph.testContext TestGraph.testGraph (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.TermLambda (Core.Lambda {
                              Core.lambdaParameter = (Core.Name "x"),
                              Core.lambdaDomain = Nothing,
                              Core.lambdaBody = (Core.TermVariable (Core.Name "x"))}))})),
                          Core.bindingTypeScheme = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [
                              Core.Name "a"],
                            Core.typeSchemeBody = (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.TermVariable (Core.Name "hydra.lib.strings.splitOn")),
                          Core.applicationArgument = (Core.TermLiteral (Core.LiteralString ","))}))}))})))),
                    Testing.universalTestCaseExpected = (ShowCore.term (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.TermLambda (Core.Lambda {
                              Core.lambdaParameter = (Core.Name "x"),
                              Core.lambdaDomain = Nothing,
                              Core.lambdaBody = (Core.TermVariable (Core.Name "x"))}))})),
                          Core.bindingTypeScheme = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [
                              Core.Name "a"],
                            Core.typeSchemeBody = (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.TermLambda (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.TermVariable (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.TestCaseUniversal (Testing.UniversalTestCase {
                    Testing.universalTestCaseActual = (Eithers.either (\e -> Strings.cat2 "ETA ERROR: " "failed") (\result -> ShowCore.term result) (Reduction.etaExpandTypedTerm TestGraph.testContext TestGraph.testGraph (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.TermLambda (Core.Lambda {
                              Core.lambdaParameter = (Core.Name "x"),
                              Core.lambdaDomain = Nothing,
                              Core.lambdaBody = (Core.TermVariable (Core.Name "x"))}))})),
                          Core.bindingTypeScheme = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [
                              Core.Name "a"],
                            Core.typeSchemeBody = (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.TermVariable (Core.Name "hydra.lib.strings.splitOn")),
                            Core.applicationArgument = (Core.TermLiteral (Core.LiteralString ","))})),
                          Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "foo,bar"))}))}))})))),
                    Testing.universalTestCaseExpected = (ShowCore.term (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.TermLambda (Core.Lambda {
                              Core.lambdaParameter = (Core.Name "x"),
                              Core.lambdaDomain = Nothing,
                              Core.lambdaBody = (Core.TermVariable (Core.Name "x"))}))})),
                          Core.bindingTypeScheme = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [
                              Core.Name "a"],
                            Core.typeSchemeBody = (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.TermVariable (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.TestCaseUniversal (Testing.UniversalTestCase {
                    Testing.universalTestCaseActual = (Eithers.either (\e -> Strings.cat2 "ETA ERROR: " "failed") (\result -> ShowCore.term result) (Reduction.etaExpandTypedTerm TestGraph.testContext TestGraph.testGraph (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.TermLambda (Core.Lambda {
                              Core.lambdaParameter = (Core.Name "x"),
                              Core.lambdaDomain = Nothing,
                              Core.lambdaBody = (Core.TermVariable (Core.Name "x"))}))})),
                          Core.bindingTypeScheme = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [
                              Core.Name "a"],
                            Core.typeSchemeBody = (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.TermVariable (Core.Name "hydra.lib.strings.splitOn"))})),
                        Core.applicationArgument = (Core.TermLiteral (Core.LiteralString ","))}))})))),
                    Testing.universalTestCaseExpected = (ShowCore.term (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.TermLambda (Core.Lambda {
                              Core.lambdaParameter = (Core.Name "x"),
                              Core.lambdaDomain = Nothing,
                              Core.lambdaBody = (Core.TermVariable (Core.Name "x"))}))})),
                          Core.bindingTypeScheme = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [
                              Core.Name "a"],
                            Core.typeSchemeBody = (Core.TypeFunction (Core.FunctionType {
                              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "a")),
                              Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "a"))})),
                            Core.typeSchemeConstraints = Nothing}))}],
                      Core.letBody = (Core.TermLambda (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.TermVariable (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.TestCaseUniversal (Testing.UniversalTestCase {
                    Testing.universalTestCaseActual = (Eithers.either (\e -> Strings.cat2 "ETA ERROR: " "failed") (\result -> ShowCore.term result) (Reduction.etaExpandTypedTerm TestGraph.testContext TestGraph.testGraph (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.TermLambda (Core.Lambda {
                              Core.lambdaParameter = (Core.Name "x"),
                              Core.lambdaDomain = Nothing,
                              Core.lambdaBody = (Core.TermVariable (Core.Name "x"))}))})),
                          Core.bindingTypeScheme = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [
                              Core.Name "a"],
                            Core.typeSchemeBody = (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.TermVariable (Core.Name "hydra.lib.strings.splitOn"))})),
                          Core.applicationArgument = (Core.TermLiteral (Core.LiteralString ","))})),
                        Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "foo,bar"))}))})))),
                    Testing.universalTestCaseExpected = (ShowCore.term (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.TermLambda (Core.Lambda {
                              Core.lambdaParameter = (Core.Name "x"),
                              Core.lambdaDomain = Nothing,
                              Core.lambdaBody = (Core.TermVariable (Core.Name "x"))}))})),
                          Core.bindingTypeScheme = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [
                              Core.Name "a"],
                            Core.typeSchemeBody = (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.TermVariable (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.TestCaseUniversal (Testing.UniversalTestCase {
                    Testing.universalTestCaseActual = (Eithers.either (\e -> Strings.cat2 "ETA ERROR: " "failed") (\result -> ShowCore.term result) (Reduction.etaExpandTypedTerm TestGraph.testContext TestGraph.testGraph (Core.TermLambda (Core.Lambda {
                      Core.lambdaParameter = (Core.Name "x"),
                      Core.lambdaDomain = Nothing,
                      Core.lambdaBody = (Core.TermVariable (Core.Name "hydra.lib.strings.splitOn"))})))),
                    Testing.universalTestCaseExpected = (ShowCore.term (Core.TermLambda (Core.Lambda {
                      Core.lambdaParameter = (Core.Name "x"),
                      Core.lambdaDomain = Nothing,
                      Core.lambdaBody = (Core.TermVariable (Core.Name "hydra.lib.strings.splitOn"))})))})),
                  Testing.testCaseWithMetadataDescription = Nothing,
                  Testing.testCaseWithMetadataTags = []},
                Testing.TestCaseWithMetadata {
                  Testing.testCaseWithMetadataName = "lambda returning bare unary primitive",
                  Testing.testCaseWithMetadataCase = (Testing.TestCaseUniversal (Testing.UniversalTestCase {
                    Testing.universalTestCaseActual = (Eithers.either (\e -> Strings.cat2 "ETA ERROR: " "failed") (\result -> ShowCore.term result) (Reduction.etaExpandTypedTerm TestGraph.testContext TestGraph.testGraph (Core.TermLambda (Core.Lambda {
                      Core.lambdaParameter = (Core.Name "x"),
                      Core.lambdaDomain = Nothing,
                      Core.lambdaBody = (Core.TermVariable (Core.Name "hydra.lib.strings.toLower"))})))),
                    Testing.universalTestCaseExpected = (ShowCore.term (Core.TermLambda (Core.Lambda {
                      Core.lambdaParameter = (Core.Name "x"),
                      Core.lambdaDomain = Nothing,
                      Core.lambdaBody = (Core.TermVariable (Core.Name "hydra.lib.strings.toLower"))})))})),
                  Testing.testCaseWithMetadataDescription = Nothing,
                  Testing.testCaseWithMetadataTags = []},
                Testing.TestCaseWithMetadata {
                  Testing.testCaseWithMetadataName = "lambda returning partially applied primitive",
                  Testing.testCaseWithMetadataCase = (Testing.TestCaseUniversal (Testing.UniversalTestCase {
                    Testing.universalTestCaseActual = (Eithers.either (\e -> Strings.cat2 "ETA ERROR: " "failed") (\result -> ShowCore.term result) (Reduction.etaExpandTypedTerm TestGraph.testContext TestGraph.testGraph (Core.TermLambda (Core.Lambda {
                      Core.lambdaParameter = (Core.Name "x"),
                      Core.lambdaDomain = Nothing,
                      Core.lambdaBody = (Core.TermApplication (Core.Application {
                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.splitOn")),
                        Core.applicationArgument = (Core.TermLiteral (Core.LiteralString ","))}))})))),
                    Testing.universalTestCaseExpected = (ShowCore.term (Core.TermLambda (Core.Lambda {
                      Core.lambdaParameter = (Core.Name "x"),
                      Core.lambdaDomain = Nothing,
                      Core.lambdaBody = (Core.TermLambda (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.TermVariable (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.TestCaseUniversal (Testing.UniversalTestCase {
                    Testing.universalTestCaseActual = (Eithers.either (\e -> Strings.cat2 "ETA ERROR: " "failed") (\result -> ShowCore.term result) (Reduction.etaExpandTypedTerm TestGraph.testContext TestGraph.testGraph (Core.TermLambda (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.TermVariable (Core.Name "hydra.lib.strings.splitOn")),
                          Core.applicationArgument = (Core.TermLiteral (Core.LiteralString ","))})),
                        Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))})))),
                    Testing.universalTestCaseExpected = (ShowCore.term (Core.TermLambda (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.TermVariable (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.TestCaseUniversal (Testing.UniversalTestCase {
                    Testing.universalTestCaseActual = (Eithers.either (\e -> Strings.cat2 "ETA ERROR: " "failed") (\result -> ShowCore.term result) (Reduction.etaExpandTypedTerm TestGraph.testContext TestGraph.testGraph (Core.TermLambda (Core.Lambda {
                      Core.lambdaParameter = (Core.Name "person"),
                      Core.lambdaDomain = Nothing,
                      Core.lambdaBody = (Core.TermProject (Core.Projection {
                        Core.projectionTypeName = TestTypes.testTypePersonName,
                        Core.projectionField = (Core.Name "firstName")}))})))),
                    Testing.universalTestCaseExpected = (ShowCore.term (Core.TermLambda (Core.Lambda {
                      Core.lambdaParameter = (Core.Name "person"),
                      Core.lambdaDomain = Nothing,
                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {
                        Core.lambdaParameter = (Core.Name "v1"),
                        Core.lambdaDomain = Nothing,
                        Core.lambdaBody = (Core.TermApplication (Core.Application {
                          Core.applicationFunction = (Core.TermProject (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.TestCaseUniversal (Testing.UniversalTestCase {
                    Testing.universalTestCaseActual = (Eithers.either (\e -> Strings.cat2 "ETA ERROR: " "failed") (\result -> ShowCore.term result) (Reduction.etaExpandTypedTerm TestGraph.testContext TestGraph.testGraph (Core.TermLambda (Core.Lambda {
                      Core.lambdaParameter = (Core.Name "x"),
                      Core.lambdaDomain = Nothing,
                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {
                        Core.lambdaParameter = (Core.Name "y"),
                        Core.lambdaDomain = Nothing,
                        Core.lambdaBody = (Core.TermApplication (Core.Application {
                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.splitOn")),
                          Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))})))),
                    Testing.universalTestCaseExpected = (ShowCore.term (Core.TermLambda (Core.Lambda {
                      Core.lambdaParameter = (Core.Name "x"),
                      Core.lambdaDomain = Nothing,
                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {
                        Core.lambdaParameter = (Core.Name "y"),
                        Core.lambdaDomain = Nothing,
                        Core.lambdaBody = (Core.TermLambda (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.TermVariable (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.TestCaseUniversal (Testing.UniversalTestCase {
                    Testing.universalTestCaseActual = (Eithers.either (\e -> Strings.cat2 "ETA ERROR: " "failed") (\result -> ShowCore.term result) (Reduction.etaExpandTypedTerm TestGraph.testContext TestGraph.testGraph (Core.TermLambda (Core.Lambda {
                      Core.lambdaParameter = (Core.Name "x"),
                      Core.lambdaDomain = Nothing,
                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {
                        Core.lambdaParameter = (Core.Name "y"),
                        Core.lambdaDomain = Nothing,
                        Core.lambdaBody = (Core.TermLambda (Core.Lambda {
                          Core.lambdaParameter = (Core.Name "z"),
                          Core.lambdaDomain = Nothing,
                          Core.lambdaBody = (Core.TermApplication (Core.Application {
                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.splitOn")),
                            Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}))})))),
                    Testing.universalTestCaseExpected = (ShowCore.term (Core.TermLambda (Core.Lambda {
                      Core.lambdaParameter = (Core.Name "x"),
                      Core.lambdaDomain = Nothing,
                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {
                        Core.lambdaParameter = (Core.Name "y"),
                        Core.lambdaDomain = Nothing,
                        Core.lambdaBody = (Core.TermLambda (Core.Lambda {
                          Core.lambdaParameter = (Core.Name "z"),
                          Core.lambdaDomain = Nothing,
                          Core.lambdaBody = (Core.TermLambda (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.TermVariable (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.TestCaseUniversal (Testing.UniversalTestCase {
                    Testing.universalTestCaseActual = (Eithers.either (\e -> Strings.cat2 "ETA ERROR: " "failed") (\result -> ShowCore.term result) (Reduction.etaExpandTypedTerm TestGraph.testContext TestGraph.testGraph (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "helper"),
                          Core.bindingTerm = (Core.TermLambda (Core.Lambda {
                            Core.lambdaParameter = (Core.Name "arg1"),
                            Core.lambdaDomain = Nothing,
                            Core.lambdaBody = (Core.TermLambda (Core.Lambda {
                              Core.lambdaParameter = (Core.Name "arg2"),
                              Core.lambdaDomain = Nothing,
                              Core.lambdaBody = (Core.TermLambda (Core.Lambda {
                                Core.lambdaParameter = (Core.Name "arg3"),
                                Core.lambdaDomain = Nothing,
                                Core.lambdaBody = (Core.TermApplication (Core.Application {
                                  Core.applicationFunction = (Core.TermVariable (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.bindingTypeScheme = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [],
                            Core.typeSchemeBody = (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.universalTestCaseExpected = (ShowCore.term (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "helper"),
                          Core.bindingTerm = (Core.TermLambda (Core.Lambda {
                            Core.lambdaParameter = (Core.Name "arg1"),
                            Core.lambdaDomain = Nothing,
                            Core.lambdaBody = (Core.TermLambda (Core.Lambda {
                              Core.lambdaParameter = (Core.Name "arg2"),
                              Core.lambdaDomain = Nothing,
                              Core.lambdaBody = (Core.TermLambda (Core.Lambda {
                                Core.lambdaParameter = (Core.Name "arg3"),
                                Core.lambdaDomain = Nothing,
                                Core.lambdaBody = (Core.TermApplication (Core.Application {
                                  Core.applicationFunction = (Core.TermVariable (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.bindingTypeScheme = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [],
                            Core.typeSchemeBody = (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.TermLambda (Core.Lambda {
                        Core.lambdaParameter = (Core.Name "v1"),
                        Core.lambdaDomain = Nothing,
                        Core.lambdaBody = (Core.TermLambda (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.TestCaseUniversal (Testing.UniversalTestCase {
                    Testing.universalTestCaseActual = (Eithers.either (\e -> Strings.cat2 "ETA ERROR: " "failed") (\result -> ShowCore.term result) (Reduction.etaExpandTypedTerm TestGraph.testContext TestGraph.testGraph (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "helper"),
                          Core.bindingTerm = (Core.TermLambda (Core.Lambda {
                            Core.lambdaParameter = (Core.Name "arg1"),
                            Core.lambdaDomain = Nothing,
                            Core.lambdaBody = (Core.TermLambda (Core.Lambda {
                              Core.lambdaParameter = (Core.Name "arg2"),
                              Core.lambdaDomain = Nothing,
                              Core.lambdaBody = (Core.TermLambda (Core.Lambda {
                                Core.lambdaParameter = (Core.Name "arg3"),
                                Core.lambdaDomain = Nothing,
                                Core.lambdaBody = (Core.TermApplication (Core.Application {
                                  Core.applicationFunction = (Core.TermVariable (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.bindingTypeScheme = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [],
                            Core.typeSchemeBody = (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.TermVariable (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.universalTestCaseExpected = (ShowCore.term (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "helper"),
                          Core.bindingTerm = (Core.TermLambda (Core.Lambda {
                            Core.lambdaParameter = (Core.Name "arg1"),
                            Core.lambdaDomain = Nothing,
                            Core.lambdaBody = (Core.TermLambda (Core.Lambda {
                              Core.lambdaParameter = (Core.Name "arg2"),
                              Core.lambdaDomain = Nothing,
                              Core.lambdaBody = (Core.TermLambda (Core.Lambda {
                                Core.lambdaParameter = (Core.Name "arg3"),
                                Core.lambdaDomain = Nothing,
                                Core.lambdaBody = (Core.TermApplication (Core.Application {
                                  Core.applicationFunction = (Core.TermVariable (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.bindingTypeScheme = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [],
                            Core.typeSchemeBody = (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.TermVariable (Core.Name "hydra.lib.lists.foldl")),
                                Core.typeApplicationTermType = (Core.TypeLiteral Core.LiteralTypeString)})),
                              Core.typeApplicationTermType = (Core.TypeLiteral Core.LiteralTypeString)})),
                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {
                              Core.lambdaParameter = (Core.Name "v1"),
                              Core.lambdaDomain = Nothing,
                              Core.lambdaBody = (Core.TermLambda (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.TestCaseUniversal (Testing.UniversalTestCase {
                    Testing.universalTestCaseActual = (Eithers.either (\e -> Strings.cat2 "ETA ERROR: " "failed") (\result -> ShowCore.term result) (Reduction.etaExpandTypedTerm TestGraph.testContext TestGraph.testGraph (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.TermLambda (Core.Lambda {
                                  Core.lambdaParameter = (Core.Name "arg1"),
                                  Core.lambdaDomain = Nothing,
                                  Core.lambdaBody = (Core.TermLambda (Core.Lambda {
                                    Core.lambdaParameter = (Core.Name "arg2"),
                                    Core.lambdaDomain = Nothing,
                                    Core.lambdaBody = (Core.TermLambda (Core.Lambda {
                                      Core.lambdaParameter = (Core.Name "arg3"),
                                      Core.lambdaDomain = Nothing,
                                      Core.lambdaBody = (Core.TermApplication (Core.Application {
                                        Core.applicationFunction = (Core.TermVariable (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.bindingTypeScheme = (Just (Core.TypeScheme {
                                  Core.typeSchemeVariables = [],
                                  Core.typeSchemeBody = (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.bindingTypeScheme = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [],
                            Core.typeSchemeBody = (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.universalTestCaseExpected = (ShowCore.term (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.TermLambda (Core.Lambda {
                                  Core.lambdaParameter = (Core.Name "arg1"),
                                  Core.lambdaDomain = Nothing,
                                  Core.lambdaBody = (Core.TermLambda (Core.Lambda {
                                    Core.lambdaParameter = (Core.Name "arg2"),
                                    Core.lambdaDomain = Nothing,
                                    Core.lambdaBody = (Core.TermLambda (Core.Lambda {
                                      Core.lambdaParameter = (Core.Name "arg3"),
                                      Core.lambdaDomain = Nothing,
                                      Core.lambdaBody = (Core.TermApplication (Core.Application {
                                        Core.applicationFunction = (Core.TermVariable (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.bindingTypeScheme = (Just (Core.TypeScheme {
                                  Core.typeSchemeVariables = [],
                                  Core.typeSchemeBody = (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.TermLambda (Core.Lambda {
                              Core.lambdaParameter = (Core.Name "v1"),
                              Core.lambdaDomain = Nothing,
                              Core.lambdaBody = (Core.TermLambda (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.bindingTypeScheme = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [],
                            Core.typeSchemeBody = (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.TestCaseUniversal (Testing.UniversalTestCase {
                    Testing.universalTestCaseActual = (Eithers.either (\e -> Strings.cat2 "ETA ERROR: " "failed") (\result -> ShowCore.term result) (Reduction.etaExpandTypedTerm TestGraph.testContext TestGraph.testGraph (Core.TermCases (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.TermLambda (Core.Lambda {
                            Core.lambdaParameter = (Core.Name "s"),
                            Core.lambdaDomain = Nothing,
                            Core.lambdaBody = (Core.TermVariable (Core.Name "s"))}))}]})))),
                    Testing.universalTestCaseExpected = (ShowCore.term (Core.TermLambda (Core.Lambda {
                      Core.lambdaParameter = (Core.Name "v1"),
                      Core.lambdaDomain = Nothing,
                      Core.lambdaBody = (Core.TermApplication (Core.Application {
                        Core.applicationFunction = (Core.TermCases (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.TermLambda (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.TestCaseUniversal (Testing.UniversalTestCase {
                    Testing.universalTestCaseActual = (Eithers.either (\e -> Strings.cat2 "ETA ERROR: " "failed") (\result -> ShowCore.term result) (Reduction.etaExpandTypedTerm TestGraph.testContext TestGraph.testGraph (Core.TermApplication (Core.Application {
                      Core.applicationFunction = (Core.TermCases (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.TermLambda (Core.Lambda {
                              Core.lambdaParameter = (Core.Name "s"),
                              Core.lambdaDomain = (Just (Core.TypeLiteral Core.LiteralTypeString)),
                              Core.lambdaBody = (Core.TermVariable (Core.Name "s"))}))}]})),
                      Core.applicationArgument = (Core.TermInject (Core.Injection {
                        Core.injectionTypeName = TestTypes.testTypeUnionMonomorphicName,
                        Core.injectionField = Core.Field {
                          Core.fieldName = (Core.Name "string"),
                          Core.fieldTerm = (Core.TermLiteral (Core.LiteralString "foo"))}}))})))),
                    Testing.universalTestCaseExpected = (ShowCore.term (Core.TermApplication (Core.Application {
                      Core.applicationFunction = (Core.TermCases (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.TermLambda (Core.Lambda {
                              Core.lambdaParameter = (Core.Name "s"),
                              Core.lambdaDomain = (Just (Core.TypeLiteral Core.LiteralTypeString)),
                              Core.lambdaBody = (Core.TermVariable (Core.Name "s"))}))}]})),
                      Core.applicationArgument = (Core.TermInject (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.TestCaseUniversal (Testing.UniversalTestCase {
                    Testing.universalTestCaseActual = (Eithers.either (\e -> Strings.cat2 "ETA ERROR: " "failed") (\result -> ShowCore.term result) (Reduction.etaExpandTypedTerm TestGraph.testContext TestGraph.testGraph (Core.TermLambda (Core.Lambda {
                      Core.lambdaParameter = (Core.Name "x"),
                      Core.lambdaDomain = (Just (Core.TypeVariable TestTypes.testTypeUnionMonomorphicName)),
                      Core.lambdaBody = (Core.TermApplication (Core.Application {
                        Core.applicationFunction = (Core.TermCases (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.TermLambda (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.universalTestCaseExpected = (ShowCore.term (Core.TermLambda (Core.Lambda {
                      Core.lambdaParameter = (Core.Name "x"),
                      Core.lambdaDomain = (Just (Core.TypeVariable TestTypes.testTypeUnionMonomorphicName)),
                      Core.lambdaBody = (Core.TermApplication (Core.Application {
                        Core.applicationFunction = (Core.TermCases (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.TermLambda (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.TestCaseUniversal (Testing.UniversalTestCase {
                    Testing.universalTestCaseActual = (Eithers.either (\e -> Strings.cat2 "ETA ERROR: " "failed") (\result -> ShowCore.term result) (Reduction.etaExpandTypedTerm TestGraph.testContext TestGraph.testGraph (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "test"),
                          Core.bindingTerm = (Core.TermCases (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.TermLambda (Core.Lambda {
                                  Core.lambdaParameter = (Core.Name "s"),
                                  Core.lambdaDomain = Nothing,
                                  Core.lambdaBody = (Core.TermVariable (Core.Name "s"))}))}]})),
                          Core.bindingTypeScheme = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [],
                            Core.typeSchemeBody = (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.universalTestCaseExpected = (ShowCore.term (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "test"),
                          Core.bindingTerm = (Core.TermLambda (Core.Lambda {
                            Core.lambdaParameter = (Core.Name "v1"),
                            Core.lambdaDomain = Nothing,
                            Core.lambdaBody = (Core.TermApplication (Core.Application {
                              Core.applicationFunction = (Core.TermCases (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.TermLambda (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.bindingTypeScheme = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [],
                            Core.typeSchemeBody = (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.TestCaseUniversal (Testing.UniversalTestCase {
                    Testing.universalTestCaseActual = (Eithers.either (\e -> Strings.cat2 "ETA ERROR: " "failed") (\result -> ShowCore.term result) (Reduction.etaExpandTypedTerm TestGraph.testContext TestGraph.testGraph (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "test"),
                          Core.bindingTerm = (Core.TermApplication (Core.Application {
                            Core.applicationFunction = (Core.TermCases (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.TermLambda (Core.Lambda {
                                    Core.lambdaParameter = (Core.Name "s"),
                                    Core.lambdaDomain = (Just (Core.TypeLiteral Core.LiteralTypeString)),
                                    Core.lambdaBody = (Core.TermVariable (Core.Name "s"))}))}]})),
                            Core.applicationArgument = (Core.TermInject (Core.Injection {
                              Core.injectionTypeName = TestTypes.testTypeUnionMonomorphicName,
                              Core.injectionField = Core.Field {
                                Core.fieldName = (Core.Name "string"),
                                Core.fieldTerm = (Core.TermLiteral (Core.LiteralString "foo"))}}))})),
                          Core.bindingTypeScheme = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [],
                            Core.typeSchemeBody = (Core.TypeLiteral Core.LiteralTypeString),
                            Core.typeSchemeConstraints = Nothing}))}],
                      Core.letBody = (Core.TermLiteral (Core.LiteralString "ignored"))})))),
                    Testing.universalTestCaseExpected = (ShowCore.term (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "test"),
                          Core.bindingTerm = (Core.TermApplication (Core.Application {
                            Core.applicationFunction = (Core.TermCases (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.TermLambda (Core.Lambda {
                                    Core.lambdaParameter = (Core.Name "s"),
                                    Core.lambdaDomain = (Just (Core.TypeLiteral Core.LiteralTypeString)),
                                    Core.lambdaBody = (Core.TermVariable (Core.Name "s"))}))}]})),
                            Core.applicationArgument = (Core.TermInject (Core.Injection {
                              Core.injectionTypeName = TestTypes.testTypeUnionMonomorphicName,
                              Core.injectionField = Core.Field {
                                Core.fieldName = (Core.Name "string"),
                                Core.fieldTerm = (Core.TermLiteral (Core.LiteralString "foo"))}}))})),
                          Core.bindingTypeScheme = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [],
                            Core.typeSchemeBody = (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.TestCaseUniversal (Testing.UniversalTestCase {
                    Testing.universalTestCaseActual = (Eithers.either (\e -> Strings.cat2 "ETA ERROR: " "failed") (\result -> ShowCore.term result) (Reduction.etaExpandTypedTerm TestGraph.testContext TestGraph.testGraph (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "test"),
                          Core.bindingTerm = (Core.TermLambda (Core.Lambda {
                            Core.lambdaParameter = (Core.Name "x"),
                            Core.lambdaDomain = (Just (Core.TypeVariable TestTypes.testTypeUnionMonomorphicName)),
                            Core.lambdaBody = (Core.TermApplication (Core.Application {
                              Core.applicationFunction = (Core.TermCases (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.TermLambda (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.bindingTypeScheme = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [],
                            Core.typeSchemeBody = (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.universalTestCaseExpected = (ShowCore.term (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "test"),
                          Core.bindingTerm = (Core.TermLambda (Core.Lambda {
                            Core.lambdaParameter = (Core.Name "x"),
                            Core.lambdaDomain = (Just (Core.TypeVariable TestTypes.testTypeUnionMonomorphicName)),
                            Core.lambdaBody = (Core.TermApplication (Core.Application {
                              Core.applicationFunction = (Core.TermCases (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.TermLambda (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.bindingTypeScheme = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [],
                            Core.typeSchemeBody = (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.TestCaseUniversal (Testing.UniversalTestCase {
                    Testing.universalTestCaseActual = (Eithers.either (\e -> Strings.cat2 "ETA ERROR: " "failed") (\result -> ShowCore.term result) (Reduction.etaExpandTypedTerm TestGraph.testContext TestGraph.testGraph (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "test"),
                          Core.bindingTerm = (Core.TermTypeApplication (Core.TypeApplicationTerm {
                            Core.typeApplicationTermBody = (Core.TermCases (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.TermLambda (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.TermVariable (Core.Name "hydra.lib.literals.showInt32")),
                                      Core.applicationArgument = (Core.TermVariable (Core.Name "i"))}))}))}]})),
                            Core.typeApplicationTermType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32))})),
                          Core.bindingTypeScheme = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [],
                            Core.typeSchemeBody = (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.universalTestCaseExpected = (ShowCore.term (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "test"),
                          Core.bindingTerm = (Core.TermLambda (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.TermCases (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.TermLambda (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.TermVariable (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.bindingTypeScheme = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [],
                            Core.typeSchemeBody = (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.TestCaseUniversal (Testing.UniversalTestCase {
                    Testing.universalTestCaseActual = (Eithers.either (\e -> Strings.cat2 "ETA ERROR: " "failed") (\result -> ShowCore.term result) (Reduction.etaExpandTypedTerm TestGraph.testContext TestGraph.testGraph (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.TermCases (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.TermLambda (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.TermVariable (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.TermInject (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.bindingTypeScheme = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [],
                            Core.typeSchemeBody = (Core.TypeLiteral Core.LiteralTypeString),
                            Core.typeSchemeConstraints = Nothing}))}],
                      Core.letBody = (Core.TermVariable (Core.Name "test"))})))),
                    Testing.universalTestCaseExpected = (ShowCore.term (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.TermCases (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.TermLambda (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.TermVariable (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.TermInject (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.bindingTypeScheme = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [],
                            Core.typeSchemeBody = (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.TestCaseUniversal (Testing.UniversalTestCase {
                    Testing.universalTestCaseActual = (Eithers.either (\e -> Strings.cat2 "ETA ERROR: " "failed") (\result -> ShowCore.term result) (Reduction.etaExpandTypedTerm TestGraph.testContext TestGraph.testGraph (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "test"),
                          Core.bindingTerm = (Core.TermLambda (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.TermCases (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.TermLambda (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.TermVariable (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.bindingTypeScheme = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [],
                            Core.typeSchemeBody = (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.universalTestCaseExpected = (ShowCore.term (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "test"),
                          Core.bindingTerm = (Core.TermLambda (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.TermCases (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.TermLambda (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.TermVariable (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.bindingTypeScheme = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [],
                            Core.typeSchemeBody = (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.TestCaseUniversal (Testing.UniversalTestCase {
                    Testing.universalTestCaseActual = (Eithers.either (\e -> Strings.cat2 "ETA ERROR: " "failed") (\result -> ShowCore.term result) (Reduction.etaExpandTypedTerm TestGraph.testContext TestGraph.testGraph (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.TermLambda (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.TermCases (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.TermLambda (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.bindingTypeScheme = (Just (Core.TypeScheme {
                              Core.typeSchemeVariables = [
                                Core.Name "t1"],
                              Core.typeSchemeBody = (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.universalTestCaseExpected = (ShowCore.term (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.TermLambda (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.TermCases (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.TermLambda (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.bindingTypeScheme = (Just (Core.TypeScheme {
                              Core.typeSchemeVariables = [
                                Core.Name "t1"],
                              Core.typeSchemeBody = (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.TestCaseUniversal (Testing.UniversalTestCase {
                    Testing.universalTestCaseActual = (Eithers.either (\e -> Strings.cat2 "ETA ERROR: " "failed") (\result -> ShowCore.term result) (Reduction.etaExpandTypedTerm TestGraph.testContext TestGraph.testGraph (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "handler"),
                          Core.bindingTerm = (Core.TermVariable (Core.Name "hydra.lib.strings.toLower")),
                          Core.bindingTypeScheme = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [],
                            Core.typeSchemeBody = (Core.TypeFunction (Core.FunctionType {
                              Core.functionTypeDomain = (Core.TypeLiteral Core.LiteralTypeString),
                              Core.functionTypeCodomain = (Core.TypeLiteral Core.LiteralTypeString)})),
                            Core.typeSchemeConstraints = Nothing}))}],
                      Core.letBody = (Core.TermCases (Core.CaseStatement {
                        Core.caseStatementTypeName = TestTypes.testTypeUnionMonomorphicName,
                        Core.caseStatementDefault = Nothing,
                        Core.caseStatementCases = [
                          Core.Field {
                            Core.fieldName = (Core.Name "bool"),
                            Core.fieldTerm = (Core.TermLambda (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.TermLambda (Core.Lambda {
                              Core.lambdaParameter = (Core.Name "ignored"),
                              Core.lambdaDomain = Nothing,
                              Core.lambdaBody = (Core.TermLiteral (Core.LiteralString "unit value"))}))}]}))})))),
                    Testing.universalTestCaseExpected = (ShowCore.term (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "handler"),
                          Core.bindingTerm = (Core.TermVariable (Core.Name "hydra.lib.strings.toLower")),
                          Core.bindingTypeScheme = (Just (Core.TypeScheme {
                            Core.typeSchemeVariables = [],
                            Core.typeSchemeBody = (Core.TypeFunction (Core.FunctionType {
                              Core.functionTypeDomain = (Core.TypeLiteral Core.LiteralTypeString),
                              Core.functionTypeCodomain = (Core.TypeLiteral Core.LiteralTypeString)})),
                            Core.typeSchemeConstraints = Nothing}))}],
                      Core.letBody = (Core.TermLambda (Core.Lambda {
                        Core.lambdaParameter = (Core.Name "v1"),
                        Core.lambdaDomain = Nothing,
                        Core.lambdaBody = (Core.TermApplication (Core.Application {
                          Core.applicationFunction = (Core.TermCases (Core.CaseStatement {
                            Core.caseStatementTypeName = TestTypes.testTypeUnionMonomorphicName,
                            Core.caseStatementDefault = Nothing,
                            Core.caseStatementCases = [
                              Core.Field {
                                Core.fieldName = (Core.Name "bool"),
                                Core.fieldTerm = (Core.TermLambda (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.TermLambda (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.TermLambda (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.TestCaseUniversal (Testing.UniversalTestCase {
                    Testing.universalTestCaseActual = (Eithers.either (\e -> Strings.cat2 "ETA ERROR: " "failed") (\result -> ShowCore.term result) (Reduction.etaExpandTypedTerm TestGraph.testContext TestGraph.testGraph (Core.TermCases (Core.CaseStatement {
                      Core.caseStatementTypeName = TestTypes.testTypeUnionMonomorphicName,
                      Core.caseStatementDefault = Nothing,
                      Core.caseStatementCases = [
                        Core.Field {
                          Core.fieldName = (Core.Name "bool"),
                          Core.fieldTerm = (Core.TermLambda (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 "hydra.lib.strings.toLower"))},
                        Core.Field {
                          Core.fieldName = (Core.Name "unit"),
                          Core.fieldTerm = (Core.TermLambda (Core.Lambda {
                            Core.lambdaParameter = (Core.Name "ignored"),
                            Core.lambdaDomain = Nothing,
                            Core.lambdaBody = (Core.TermLiteral (Core.LiteralString "unit value"))}))}]})))),
                    Testing.universalTestCaseExpected = (ShowCore.term (Core.TermLambda (Core.Lambda {
                      Core.lambdaParameter = (Core.Name "v1"),
                      Core.lambdaDomain = Nothing,
                      Core.lambdaBody = (Core.TermApplication (Core.Application {
                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {
                          Core.caseStatementTypeName = TestTypes.testTypeUnionMonomorphicName,
                          Core.caseStatementDefault = Nothing,
                          Core.caseStatementCases = [
                            Core.Field {
                              Core.fieldName = (Core.Name "bool"),
                              Core.fieldTerm = (Core.TermLambda (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.TermLambda (Core.Lambda {
                                Core.lambdaParameter = (Core.Name "v1"),
                                Core.lambdaDomain = Nothing,
                                Core.lambdaBody = (Core.TermApplication (Core.Application {
                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.toLower")),
                                  Core.applicationArgument = (Core.TermVariable (Core.Name "v1"))}))}))},
                            Core.Field {
                              Core.fieldName = (Core.Name "unit"),
                              Core.fieldTerm = (Core.TermLambda (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.TestCaseUniversal (Testing.UniversalTestCase {
                    Testing.universalTestCaseActual = (Eithers.either (\e -> Strings.cat2 "ETA ERROR: " "failed") (\result -> ShowCore.term result) (Reduction.etaExpandTypedTerm TestGraph.testContext TestGraph.testGraph (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "handler"),
                          Core.bindingTerm = (Core.TermVariable (Core.Name "hydra.lib.strings.toLower")),
                          Core.bindingTypeScheme = Nothing}],
                      Core.letBody = (Core.TermVariable (Core.Name "handler"))})))),
                    Testing.universalTestCaseExpected = (ShowCore.term (Core.TermLet (Core.Let {
                      Core.letBindings = [
                        Core.Binding {
                          Core.bindingName = (Core.Name "handler"),
                          Core.bindingTerm = (Core.TermVariable (Core.Name "hydra.lib.strings.toLower")),
                          Core.bindingTypeScheme = 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.TestCaseUniversal (Testing.UniversalTestCase {
                    Testing.universalTestCaseActual = (Eithers.either (\e -> Strings.cat2 "ETA ERROR: " "failed") (\result -> ShowCore.term result) (Reduction.etaExpandTypedTerm TestGraph.testContext TestGraph.testGraph (Core.TermVariable (Core.Name "hydra.lib.strings.toLower")))),
                    Testing.universalTestCaseExpected = (ShowCore.term (Core.TermVariable (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.TestCaseUniversal (Testing.UniversalTestCase {
                Testing.universalTestCaseActual = (Eithers.either (\e -> Strings.cat2 "ETA ERROR: " "failed") (\result -> ShowCore.term result) (Reduction.etaExpandTypedTerm TestGraph.testContext TestGraph.testGraph (Core.TermTypeLambda (Core.TypeLambda {
                  Core.typeLambdaParameter = (Core.Name "t0"),
                  Core.typeLambdaBody = (Core.TermLambda (Core.Lambda {
                    Core.lambdaParameter = (Core.Name "dir"),
                    Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.coders.CoderDirection"))),
                    Core.lambdaBody = (Core.TermLambda (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.coders.Coder")),
                          Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "t0"))})),
                        Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "t0"))}))),
                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {
                        Core.lambdaParameter = (Core.Name "cx"),
                        Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.context.Context"))),
                        Core.lambdaBody = (Core.TermLambda (Core.Lambda {
                          Core.lambdaParameter = (Core.Name "v1"),
                          Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "t0"))),
                          Core.lambdaBody = (Core.TermApplication (Core.Application {
                            Core.applicationFunction = (Core.TermCases (Core.CaseStatement {
                              Core.caseStatementTypeName = (Core.Name "hydra.coders.CoderDirection"),
                              Core.caseStatementDefault = Nothing,
                              Core.caseStatementCases = [
                                Core.Field {
                                  Core.fieldName = (Core.Name "encode"),
                                  Core.fieldTerm = (Core.TermLambda (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.TermProject (Core.Projection {
                                                Core.projectionTypeName = (Core.Name "hydra.coders.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.TermLambda (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.TermProject (Core.Projection {
                                                Core.projectionTypeName = (Core.Name "hydra.coders.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.universalTestCaseExpected = (ShowCore.term (Core.TermTypeLambda (Core.TypeLambda {
                  Core.typeLambdaParameter = (Core.Name "t0"),
                  Core.typeLambdaBody = (Core.TermLambda (Core.Lambda {
                    Core.lambdaParameter = (Core.Name "dir"),
                    Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.coders.CoderDirection"))),
                    Core.lambdaBody = (Core.TermLambda (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.coders.Coder")),
                          Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "t0"))})),
                        Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "t0"))}))),
                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {
                        Core.lambdaParameter = (Core.Name "cx"),
                        Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "hydra.context.Context"))),
                        Core.lambdaBody = (Core.TermLambda (Core.Lambda {
                          Core.lambdaParameter = (Core.Name "v1"),
                          Core.lambdaDomain = (Just (Core.TypeVariable (Core.Name "t0"))),
                          Core.lambdaBody = (Core.TermApplication (Core.Application {
                            Core.applicationFunction = (Core.TermCases (Core.CaseStatement {
                              Core.caseStatementTypeName = (Core.Name "hydra.coders.CoderDirection"),
                              Core.caseStatementDefault = Nothing,
                              Core.caseStatementCases = [
                                Core.Field {
                                  Core.fieldName = (Core.Name "encode"),
                                  Core.fieldTerm = (Core.TermLambda (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.TermProject (Core.Projection {
                                                Core.projectionTypeName = (Core.Name "hydra.coders.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.TermLambda (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.TermProject (Core.Projection {
                                                Core.projectionTypeName = (Core.Name "hydra.coders.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.Tag "disabled"]},
            Testing.TestCaseWithMetadata {
              Testing.testCaseWithMetadataName = "applied projection",
              Testing.testCaseWithMetadataCase = (Testing.TestCaseUniversal (Testing.UniversalTestCase {
                Testing.universalTestCaseActual = (Eithers.either (\e -> Strings.cat2 "ETA ERROR: " "failed") (\result -> ShowCore.term result) (Reduction.etaExpandTypedTerm TestGraph.testContext TestGraph.testGraph (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.TermProject (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.TermLambda (Core.Lambda {
                          Core.lambdaParameter = (Core.Name "s"),
                          Core.lambdaDomain = Nothing,
                          Core.lambdaBody = (Core.TermApplication (Core.Application {
                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.toLower")),
                            Core.applicationArgument = (Core.TermVariable (Core.Name "s"))}))}))}]}))})))),
                Testing.universalTestCaseExpected = (ShowCore.term (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.TermProject (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.TermLambda (Core.Lambda {
                          Core.lambdaParameter = (Core.Name "s"),
                          Core.lambdaDomain = Nothing,
                          Core.lambdaBody = (Core.TermApplication (Core.Application {
                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.toLower")),
                            Core.applicationArgument = (Core.TermVariable (Core.Name "s"))}))}))}]}))})))})),
              Testing.testCaseWithMetadataDescription = Nothing,
              Testing.testCaseWithMetadataTags = []}]}],
      Testing.testGroupCases = []}