dhall-1.3.0: tests/Examples.hs

{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE QuasiQuotes       #-}

module Examples where

import qualified NeatInterpolation
import qualified Test.Tasty
import qualified Test.Tasty.HUnit
import qualified Util

import Test.Tasty (TestTree)

exampleTests :: TestTree
exampleTests =
    Test.Tasty.testGroup "examples"
        [ Test.Tasty.testGroup "Bool"
            [ Test.Tasty.testGroup "and"
                [ _Bool_and_0
                , _Bool_and_1
                ]
            , Test.Tasty.testGroup "build"
                [ _Bool_build_0
                , _Bool_build_1
                ]
            , Test.Tasty.testGroup "even"
                [ _Bool_even_0
                , _Bool_even_1
                , _Bool_even_2
                , _Bool_even_3
                ]
            , Test.Tasty.testGroup "fold"
                [ _Bool_fold_0
                , _Bool_fold_1
                ]
            , Test.Tasty.testGroup "not"
                [ _Bool_not_0
                , _Bool_not_1
                ]
            , Test.Tasty.testGroup "odd"
                [ _Bool_odd_0
                , _Bool_odd_1
                , _Bool_odd_2
                , _Bool_odd_3
                ]
            , Test.Tasty.testGroup "or"
                [ _Bool_or_0
                , _Bool_or_1
                ]
            , Test.Tasty.testGroup "show"
                [ _Bool_show_0
                , _Bool_show_1
                ]
            ]
        , Test.Tasty.testGroup "Double"
            [ Test.Tasty.testGroup "show"
                [ _Double_show_0
                , _Double_show_1
                ]
            ]
        , Test.Tasty.testGroup "Integer"
            [ Test.Tasty.testGroup "show"
                [ _Integer_show_0
                , _Integer_show_1
                ]
            ]
        , Test.Tasty.testGroup "List"
            [ Test.Tasty.testGroup "all"
                [ _List_all_0
                , _List_all_1
                ]
            , Test.Tasty.testGroup "any"
                [ _List_any_0
                , _List_any_1
                ]
            , Test.Tasty.testGroup "build"
                [ _List_build_0
                , _List_build_1
                ]
            , Test.Tasty.testGroup "concat"
                [ _List_concat_0
                , _List_concat_1
                ]
            , Test.Tasty.testGroup "filter"
                [ _List_filter_0
                , _List_filter_1
                ]
            , Test.Tasty.testGroup "fold"
                [ _List_fold_0
                , _List_fold_1
                , _List_fold_2
                ]
            , Test.Tasty.testGroup "generate"
                [ _List_generate_0
                , _List_generate_1
                ]
            , Test.Tasty.testGroup "head"
                [ _List_head_0
                , _List_head_1
                ]
            , Test.Tasty.testGroup "indexed"
                [ _List_indexed_0
                , _List_indexed_1
                ]
            , Test.Tasty.testGroup "iterate"
                [ _List_iterate_0
                , _List_iterate_1
                ]
            , Test.Tasty.testGroup "last"
                [ _List_last_0
                , _List_last_1
                ]
            , Test.Tasty.testGroup "length"
                [ _List_length_0
                , _List_length_1
                ]
            , Test.Tasty.testGroup "map"
                [ _List_map_0
                , _List_map_1
                ]
            , Test.Tasty.testGroup "null"
                [ _List_null_0
                , _List_null_1
                ]
            , Test.Tasty.testGroup "replicate"
                [ _List_replicate_0
                , _List_replicate_1
                ]
            , Test.Tasty.testGroup "reverse"
                [ _List_reverse_0
                , _List_reverse_1
                ]
            , Test.Tasty.testGroup "shifted"
                [ _List_shifted_0
                , _List_shifted_1
                ]
            , Test.Tasty.testGroup "unzip"
                [ _List_unzip_0
                , _List_unzip_1
                ]
            ]
        , Test.Tasty.testGroup "Monoid"
            [ _Monoid_00
            , _Monoid_01
            , _Monoid_02
            , _Monoid_03
            , _Monoid_04
            , _Monoid_05
            , _Monoid_06
            , _Monoid_07
            , _Monoid_08
            , _Monoid_09
            , _Monoid_10
            ]
        , Test.Tasty.testGroup "Natural"
            [ Test.Tasty.testGroup "build"
                [ _Natural_build_0
                , _Natural_build_1
                ]
            , Test.Tasty.testGroup "enumerate"
                [ _Natural_enumerate_0
                , _Natural_enumerate_1
                ]
            , Test.Tasty.testGroup "even"
                [ _Natural_even_0
                , _Natural_even_1
                ]
            , Test.Tasty.testGroup "fold"
                [ _Natural_fold_0
                , _Natural_fold_1
                , _Natural_fold_2
                ]
            , Test.Tasty.testGroup "isZero"
                [ _Natural_isZero_0
                , _Natural_isZero_1
                ]
            , Test.Tasty.testGroup "odd"
                [ _Natural_odd_0
                , _Natural_odd_1
                ]
            , Test.Tasty.testGroup "product"
                [ _Natural_product_0
                , _Natural_product_1
                ]
            , Test.Tasty.testGroup "show"
                [ _Natural_show_0
                , _Natural_show_1
                ]
            , Test.Tasty.testGroup "sum"
                [ _Natural_sum_0
                , _Natural_sum_1
                ]
            , Test.Tasty.testGroup "toInteger"
                [ _Natural_toInteger_0
                , _Natural_toInteger_1
                ]
            ]
        , Test.Tasty.testGroup "Optional"
            [ Test.Tasty.testGroup "build"
                [ _Optional_build_0
                , _Optional_build_1
                ]
            , Test.Tasty.testGroup "concat"
                [ _Optional_concat_0
                , _Optional_concat_1
                , _Optional_concat_2
                ]
            , Test.Tasty.testGroup "fold"
                [ _Optional_fold_0
                , _Optional_fold_1
                ]
            , Test.Tasty.testGroup "head"
                [ _Optional_head_0
                , _Optional_head_1
                , _Optional_head_2
                ]
            , Test.Tasty.testGroup "last"
                [ _Optional_last_0
                , _Optional_last_1
                , _Optional_last_2
                ]
            , Test.Tasty.testGroup "map"
                [ _Optional_map_0
                , _Optional_map_1
                ]
            , Test.Tasty.testGroup "toList"
                [ _Optional_toList_0
                , _Optional_toList_1
                ]
            , Test.Tasty.testGroup "unzip"
                [ _Optional_unzip_0
                , _Optional_unzip_1
                ]
            ]
        , Test.Tasty.testGroup "Text"
            [ Test.Tasty.testGroup "concat"
                [ _Text_concat_0
                , _Text_concat_1
                ]
            ]
        ]

_Bool_and_0 :: TestTree
_Bool_and_0 = Test.Tasty.HUnit.testCase "Example #0" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Bool/and ([True, False, True] : List Bool)
|]
    Util.assertNormalizesTo e "False" )

_Bool_and_1 :: TestTree
_Bool_and_1 = Test.Tasty.HUnit.testCase "Example #1" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Bool/and ([] : List Bool)
|]
    Util.assertNormalizesTo e "True" )

_Bool_build_0 :: TestTree
_Bool_build_0 = Test.Tasty.HUnit.testCase "Example #0" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Bool/build (λ(bool : Type) → λ(true : bool) → λ(false : bool) → true)
|]
    Util.assertNormalizesTo e "True" )

_Bool_build_1 :: TestTree
_Bool_build_1 = Test.Tasty.HUnit.testCase "Example #1" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Bool/build (λ(bool : Type) → λ(true : bool) → λ(false : bool) → false)
|]
    Util.assertNormalizesTo e "False" )

_Bool_even_0 :: TestTree
_Bool_even_0 = Test.Tasty.HUnit.testCase "Example #0" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Bool/even ([False, True, False] : List Bool)
|]
    Util.assertNormalizesTo e "True" )

_Bool_even_1 :: TestTree
_Bool_even_1 = Test.Tasty.HUnit.testCase "Example #1" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Bool/even ([False, True] : List Bool)
|]
    Util.assertNormalizesTo e "False" )

_Bool_even_2 :: TestTree
_Bool_even_2 = Test.Tasty.HUnit.testCase "Example #2" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Bool/even ([False] : List Bool)
|]
    Util.assertNormalizesTo e "False" )

_Bool_even_3 :: TestTree
_Bool_even_3 = Test.Tasty.HUnit.testCase "Example #3" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Bool/even ([] : List Bool)
|]
    Util.assertNormalizesTo e "True" )

_Bool_fold_0 :: TestTree
_Bool_fold_0 = Test.Tasty.HUnit.testCase "Example #0" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Bool/fold True Integer 0 1
|]
    Util.assertNormalizesTo e "0" )

_Bool_fold_1 :: TestTree
_Bool_fold_1 = Test.Tasty.HUnit.testCase "Example #1" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Bool/fold False Integer 0 1
|]
    Util.assertNormalizesTo e "1" )

_Bool_not_0 :: TestTree
_Bool_not_0 = Test.Tasty.HUnit.testCase "Example #0" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Bool/not True
|]
    Util.assertNormalizesTo e "False" )

_Bool_not_1 :: TestTree
_Bool_not_1 = Test.Tasty.HUnit.testCase "Example #1" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Bool/not False
|]
    Util.assertNormalizesTo e "True" )

_Bool_odd_0 :: TestTree
_Bool_odd_0 = Test.Tasty.HUnit.testCase "Example #0" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Bool/odd ([True, False, True] : List Bool)
|]
    Util.assertNormalizesTo e "False" )

_Bool_odd_1 :: TestTree
_Bool_odd_1 = Test.Tasty.HUnit.testCase "Example #1" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Bool/odd ([True, False] : List Bool)
|]
    Util.assertNormalizesTo e "True" )

_Bool_odd_2 :: TestTree
_Bool_odd_2 = Test.Tasty.HUnit.testCase "Example #2" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Bool/odd ([True] : List Bool)
|]
    Util.assertNormalizesTo e "True" )

_Bool_odd_3 :: TestTree
_Bool_odd_3 = Test.Tasty.HUnit.testCase "Example #3" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Bool/odd ([] : List Bool)
|]
    Util.assertNormalizesTo e "False" )

_Bool_or_0 :: TestTree
_Bool_or_0 = Test.Tasty.HUnit.testCase "Example #0" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Bool/or ([True, False, True] : List Bool)
|]
    Util.assertNormalizesTo e "True" )

_Bool_or_1 :: TestTree
_Bool_or_1 = Test.Tasty.HUnit.testCase "Example #1" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Bool/or ([] : List Bool)
|]
    Util.assertNormalizesTo e "False" )

_Bool_show_0 :: TestTree
_Bool_show_0 = Test.Tasty.HUnit.testCase "Example #0" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Bool/show True
|]
    Util.assertNormalizesTo e "\"True\"" )

_Bool_show_1 :: TestTree
_Bool_show_1 = Test.Tasty.HUnit.testCase "Example #1" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Bool/show False
|]
    Util.assertNormalizesTo e "\"False\"" )

_Double_show_0 :: TestTree
_Double_show_0 = Test.Tasty.HUnit.testCase "Example #0" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Double/show -3.1
|]
    Util.assertNormalizesTo e "\"-3.1\"" )

_Double_show_1 :: TestTree
_Double_show_1 = Test.Tasty.HUnit.testCase "Example #1" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Double/show 0.4
|]
    Util.assertNormalizesTo e "\"0.4\"" )

_Integer_show_0 :: TestTree
_Integer_show_0 = Test.Tasty.HUnit.testCase "Example #0" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Integer/show -3
|]
    Util.assertNormalizesTo e "\"-3\"" )

_Integer_show_1 :: TestTree
_Integer_show_1 = Test.Tasty.HUnit.testCase "Example #1" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Integer/show 0
|]
    Util.assertNormalizesTo e "\"0\"" )

_List_all_0 :: TestTree
_List_all_0 = Test.Tasty.HUnit.testCase "Example #0" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/List/all Natural Natural/even ([+2, +3, +5] : List Natural)
|]
    Util.assertNormalizesTo e "False" )

_List_all_1 :: TestTree
_List_all_1 = Test.Tasty.HUnit.testCase "Example #1" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/List/all Natural Natural/even ([] : List Natural)
|]
    Util.assertNormalizesTo e "True" )

_List_any_0 :: TestTree
_List_any_0 = Test.Tasty.HUnit.testCase "Example #0" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/List/any Natural Natural/even ([+2, +3, +5] : List Natural)
|]
    Util.assertNormalizesTo e "True" )

_List_any_1 :: TestTree
_List_any_1 = Test.Tasty.HUnit.testCase "Example #1" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/List/any Natural Natural/even ([] : List Natural)
|]
    Util.assertNormalizesTo e "False" )

_List_build_0 :: TestTree
_List_build_0 = Test.Tasty.HUnit.testCase "Example #0" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/List/build
Text
(   λ(list : Type)
→   λ(cons : Text → list → list)
→   λ(nil : list)
→   cons "ABC" (cons "DEF" nil)
)
|]
    Util.assertNormalizesTo e "[\"ABC\", \"DEF\"] : List Text" )

_List_build_1 :: TestTree
_List_build_1 = Test.Tasty.HUnit.testCase "Example #1" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/List/build
Text
(   λ(list : Type)
→   λ(cons : Text → list → list)
→   λ(nil : list)
→   nil
)
|]
    Util.assertNormalizesTo e "[] : List Text" )

_List_concat_0 :: TestTree
_List_concat_0 = Test.Tasty.HUnit.testCase "Example #0" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/List/concat Integer
(   [   [0, 1, 2]    : List Integer
    ,   [3, 4]       : List Integer
    ,   [5, 6, 7, 8] : List Integer
    ]   : List (List Integer)
)
|]
    Util.assertNormalizesTo e "[0, 1, 2, 3, 4, 5, 6, 7, 8] : List Integer" )

_List_concat_1 :: TestTree
_List_concat_1 = Test.Tasty.HUnit.testCase "Example #1" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/List/concat Integer
(   [   [] : List Integer
    ,   [] : List Integer
    ,   [] : List Integer
    ]   : List (List Integer)
)
|]
    Util.assertNormalizesTo e "[] : List Integer" )

_List_filter_0 :: TestTree
_List_filter_0 = Test.Tasty.HUnit.testCase "Example #0" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/List/filter Natural Natural/even ([+2, +3, +5] : List Natural)
|]
    Util.assertNormalizesTo e "[+2] : List Natural" )

_List_filter_1 :: TestTree
_List_filter_1 = Test.Tasty.HUnit.testCase "Example #1" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/List/filter Natural Natural/odd ([+2, +3, +5] : List Natural)
|]
    Util.assertNormalizesTo e "[+3, +5] : List Natural" )

_List_fold_0 :: TestTree
_List_fold_0 = Test.Tasty.HUnit.testCase "Example #0" (do
    e <- Util.code [NeatInterpolation.text|
    ./Prelude/List/fold
    Natural
    ([+2, +3, +5] : List Natural)
    Natural
    (λ(x : Natural) → λ(y : Natural) → x + y)
    +0
|]
    Util.assertNormalizesTo e "+10" )

_List_fold_1 :: TestTree
_List_fold_1 = Test.Tasty.HUnit.testCase "Example #1" (do
    e <- Util.code [NeatInterpolation.text|
    λ(nil : Natural)
→   ./Prelude/List/fold
    Natural
    ([+2, +3, +5] : List Natural)
    Natural
    (λ(x : Natural) → λ(y : Natural) → x + y)
    nil
|]
    Util.assertNormalizesTo e "λ(nil : Natural) → +2 + +3 + +5 + nil" )

_List_fold_2 :: TestTree
_List_fold_2 = Test.Tasty.HUnit.testCase "Example #2" (do
    e <- Util.code [NeatInterpolation.text|
    λ(list : Type)
→   λ(cons : Natural → list → list)
→   λ(nil : list)
→   ./Prelude/List/fold Natural ([+2, +3, +5] : List Natural) list cons nil
|]
    Util.assertNormalizesTo e "λ(list : Type) → λ(cons : Natural → list → list) → λ(nil : list) → cons +2 (cons +3 (cons +5 nil))" )

_List_generate_0 :: TestTree
_List_generate_0 = Test.Tasty.HUnit.testCase "Example #0" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/List/generate +5 Bool Natural/even
|]
    Util.assertNormalizesTo e "[True, False, True, False, True] : List Bool" )

_List_generate_1 :: TestTree
_List_generate_1 = Test.Tasty.HUnit.testCase "Example #1" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/List/generate +0 Bool Natural/even
|]
    Util.assertNormalizesTo e "[] : List Bool" )

_List_head_0 :: TestTree
_List_head_0 = Test.Tasty.HUnit.testCase "Example #0" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/List/head Integer ([0, 1, 2] : List Integer)
|]
    Util.assertNormalizesTo e "[0] : Optional Integer" )

_List_head_1 :: TestTree
_List_head_1 = Test.Tasty.HUnit.testCase "Example #1" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/List/head Integer ([] : List Integer)
|]
    Util.assertNormalizesTo e "[] : Optional Integer" )

_List_indexed_0 :: TestTree
_List_indexed_0 = Test.Tasty.HUnit.testCase "Example #0" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/List/indexed Bool ([True, False, True] : List Bool)
|]
    Util.assertNormalizesTo e "[{ index = +0, value = True }, { index = +1, value = False }, { index = +2, value = True }] : List { index : Natural, value : Bool }" )

_List_indexed_1 :: TestTree
_List_indexed_1 = Test.Tasty.HUnit.testCase "Example #1" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/List/indexed Bool ([] : List Bool)
|]
    Util.assertNormalizesTo e "[] : List { index : Natural, value : Bool }" )

_List_iterate_0 :: TestTree
_List_iterate_0 = Test.Tasty.HUnit.testCase "Example #0" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/List/iterate +10 Natural (λ(x : Natural) → x * +2) +1
|]
    Util.assertNormalizesTo e "[+1, +2, +4, +8, +16, +32, +64, +128, +256, +512] : List Natural" )

_List_iterate_1 :: TestTree
_List_iterate_1 = Test.Tasty.HUnit.testCase "Example #1" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/List/iterate +0 Natural (λ(x : Natural) → x * +2) +1
|]
    Util.assertNormalizesTo e "[] : List Natural" )

_List_last_0 :: TestTree
_List_last_0 = Test.Tasty.HUnit.testCase "Example #0" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/List/last Integer ([0, 1, 2] : List Integer)
|]
    Util.assertNormalizesTo e "[2] : Optional Integer" )

_List_last_1 :: TestTree
_List_last_1 = Test.Tasty.HUnit.testCase "Example #1" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/List/last Integer ([] : List Integer)
|]
    Util.assertNormalizesTo e "[] : Optional Integer" )

_List_length_0 :: TestTree
_List_length_0 = Test.Tasty.HUnit.testCase "Example #0" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/List/length Integer ([0, 1, 2] : List Integer)
|]
    Util.assertNormalizesTo e "+3" )

_List_length_1 :: TestTree
_List_length_1 = Test.Tasty.HUnit.testCase "Example #1" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/List/length Integer ([] : List Integer)
|]
    Util.assertNormalizesTo e "+0" )

_List_map_0 :: TestTree
_List_map_0 = Test.Tasty.HUnit.testCase "Example #0" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/List/map Natural Bool Natural/even ([+2, +3, +5] : List Natural)
|]
    Util.assertNormalizesTo e "[True, False, False] : List Bool" )

_List_map_1 :: TestTree
_List_map_1 = Test.Tasty.HUnit.testCase "Example #1" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/List/map Natural Bool Natural/even ([] : List Natural)
|]
    Util.assertNormalizesTo e "[] : List Bool" )

_List_null_0 :: TestTree
_List_null_0 = Test.Tasty.HUnit.testCase "Example #0" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/List/null Integer ([0, 1, 2] : List Integer)
|]
    Util.assertNormalizesTo e "False" )

_List_null_1 :: TestTree
_List_null_1 = Test.Tasty.HUnit.testCase "Example #1" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/List/null Integer ([] : List Integer)
|]
    Util.assertNormalizesTo e "True" )

_List_replicate_0 :: TestTree
_List_replicate_0 = Test.Tasty.HUnit.testCase "Example #0" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/List/replicate +9 Integer 1
|]
    Util.assertNormalizesTo e "[1, 1, 1, 1, 1, 1, 1, 1, 1] : List Integer" )

_List_replicate_1 :: TestTree
_List_replicate_1 = Test.Tasty.HUnit.testCase "Example #1" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/List/replicate +0 Integer 1
|]
    Util.assertNormalizesTo e "[] : List Integer" )

_List_reverse_0 :: TestTree
_List_reverse_0 = Test.Tasty.HUnit.testCase "Example #0" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/List/reverse Integer ([0, 1, 2] : List Integer)
|]
    Util.assertNormalizesTo e "[2, 1, 0] : List Integer" )

_List_reverse_1 :: TestTree
_List_reverse_1 = Test.Tasty.HUnit.testCase "Example #1" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/List/reverse Integer ([] : List Integer)
|]
    Util.assertNormalizesTo e "[] : List Integer" )

_List_shifted_0 :: TestTree
_List_shifted_0 = Test.Tasty.HUnit.testCase "Example #0" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/List/shifted
Bool
(   [   [   { index = +0, value = True  }
        ,   { index = +1, value = True  }
        ,   { index = +2, value = True  }
        ]   : List { index : Natural, value : Bool }
    ,   [   { index = +0, value = False }
        ,   { index = +1, value = False }
        ]   : List { index : Natural, value : Bool }
    ,   [   { index = +0, value = True  }
        ,   { index = +1, value = True  }
        ,   { index = +2, value = True  }
        ,   { index = +3, value = True  }
        ]   : List { index : Natural, value : Bool }
    ]   : List (List { index : Natural, value : Bool })
)
|]
    Util.assertNormalizesTo e "[{ index = +0, value = True }, { index = +1, value = True }, { index = +2, value = True }, { index = +3, value = False }, { index = +4, value = False }, { index = +5, value = True }, { index = +6, value = True }, { index = +7, value = True }, { index = +8, value = True }] : List { index : Natural, value : Bool }" )

_List_shifted_1 :: TestTree
_List_shifted_1 = Test.Tasty.HUnit.testCase "Example #1" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/List/shifted Bool ([] : List (List { index : Natural, value : Bool }))
|]
    Util.assertNormalizesTo e "[] : List { index : Natural, value : Bool }" )

_List_unzip_0 :: TestTree
_List_unzip_0 = Test.Tasty.HUnit.testCase "Example #0" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/List/unzip
Text
Bool
(   [   { _1 = "ABC", _2 = True  }
    ,   { _1 = "DEF", _2 = False }
    ,   { _1 = "GHI", _2 = True  }
    ]   : List { _1 : Text, _2 : Bool }
)
|]
    Util.assertNormalizesTo e "{ _1 = [\"ABC\", \"DEF\", \"GHI\"] : List Text, _2 = [True, False, True] : List Bool }" )

_List_unzip_1 :: TestTree
_List_unzip_1 = Test.Tasty.HUnit.testCase "Example #1" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/List/unzip Text Bool ([] : List { _1 : Text, _2 : Bool })
|]
    Util.assertNormalizesTo e "{ _1 = [] : List Text, _2 = [] : List Bool }" )

_Monoid_00 :: TestTree
_Monoid_00 = Test.Tasty.HUnit.testCase "Example #0"
    (Util.assertTypeChecks [NeatInterpolation.text|
./Prelude/Bool/and
    : ./Prelude/Monoid Bool
|] )

_Monoid_01 :: TestTree
_Monoid_01 = Test.Tasty.HUnit.testCase "Example #1"
    (Util.assertTypeChecks [NeatInterpolation.text|
./Prelude/Bool/or
    : ./Prelude/Monoid Bool
|] )

_Monoid_02 :: TestTree
_Monoid_02 = Test.Tasty.HUnit.testCase "Example #2"
    (Util.assertTypeChecks [NeatInterpolation.text|
./Prelude/Bool/even
    : ./Prelude/Monoid Bool
|] )

_Monoid_03 :: TestTree
_Monoid_03 = Test.Tasty.HUnit.testCase "Example #3"
    (Util.assertTypeChecks[NeatInterpolation.text|
./Prelude/Bool/odd
    : ./Prelude/Monoid Bool
|] )

_Monoid_04 :: TestTree
_Monoid_04 = Test.Tasty.HUnit.testCase "Example #4"
    (Util.assertTypeChecks [NeatInterpolation.text|
./Prelude/List/concat
    : ∀(a : Type) → ./Prelude/Monoid (List a)
|] )

_Monoid_05 :: TestTree
_Monoid_05 = Test.Tasty.HUnit.testCase "Example #5"
    (Util.assertTypeChecks [NeatInterpolation.text|
./Prelude/List/shifted
    : ∀(a : Type) → ./Prelude/Monoid (List { index : Natural, value : a })
|] )

_Monoid_06 :: TestTree
_Monoid_06 = Test.Tasty.HUnit.testCase "Example #6"
    (Util.assertTypeChecks [NeatInterpolation.text|
./Prelude/Natural/sum
    : ./Prelude/Monoid Natural
|] )

_Monoid_07 :: TestTree
_Monoid_07 = Test.Tasty.HUnit.testCase "Example #7"
    (Util.assertTypeChecks [NeatInterpolation.text|
./Prelude/Natural/product
    : ./Prelude/Monoid Natural
|] )

_Monoid_08 :: TestTree
_Monoid_08 = Test.Tasty.HUnit.testCase "Example #8"
    (Util.assertTypeChecks [NeatInterpolation.text|
./Prelude/Optional/head
    : ∀(a : Type) → ./Prelude/Monoid (Optional a)
|] )

_Monoid_09 :: TestTree
_Monoid_09 = Test.Tasty.HUnit.testCase "Example #9"
    (Util.assertTypeChecks [NeatInterpolation.text|
./Prelude/Optional/last
    : ∀(a : Type) → ./Prelude/Monoid (Optional a)
|] )

_Monoid_10 :: TestTree
_Monoid_10 = Test.Tasty.HUnit.testCase "Example #10"
    (Util.assertTypeChecks [NeatInterpolation.text|
./Prelude/Text/concat
    : ./Prelude/Monoid Text
|] )

_Natural_build_0 :: TestTree
_Natural_build_0 = Test.Tasty.HUnit.testCase "Example #0" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Natural/build
(   λ(natural : Type)
→   λ(succ : natural → natural)
→   λ(zero : natural)
→   succ (succ (succ zero))
)
|]
    Util.assertNormalizesTo e "+3" )

_Natural_build_1 :: TestTree
_Natural_build_1 = Test.Tasty.HUnit.testCase "Example #1" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Natural/build
(   λ(natural : Type)
→   λ(succ : natural → natural)
→   λ(zero : natural)
→   zero
)
|]
    Util.assertNormalizesTo e "+0" )

_Natural_enumerate_0 :: TestTree
_Natural_enumerate_0 = Test.Tasty.HUnit.testCase "Example #0" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Natural/enumerate +10
|]
    Util.assertNormalizesTo e "[+0, +1, +2, +3, +4, +5, +6, +7, +8, +9] : List Natural" )

_Natural_enumerate_1 :: TestTree
_Natural_enumerate_1 = Test.Tasty.HUnit.testCase "Example #1" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Natural/enumerate +0
|]
    Util.assertNormalizesTo e "[] : List Natural" )

_Natural_even_0 :: TestTree
_Natural_even_0 = Test.Tasty.HUnit.testCase "Example #0" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Natural/even +3
|]
    Util.assertNormalizesTo e "False" )

_Natural_even_1 :: TestTree
_Natural_even_1 = Test.Tasty.HUnit.testCase "Example #1" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Natural/even +0
|]
    Util.assertNormalizesTo e "True" )

_Natural_fold_0 :: TestTree
_Natural_fold_0 = Test.Tasty.HUnit.testCase "Example #0" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Natural/fold +3 Natural (λ(x : Natural) → +5 * x) +1
|]
    Util.assertNormalizesTo e "+125" )

_Natural_fold_1 :: TestTree
_Natural_fold_1 = Test.Tasty.HUnit.testCase "Example #1" (do
    e <- Util.code [NeatInterpolation.text|
λ(zero : Natural) → ./Prelude/Natural/fold +3 Natural (λ(x : Natural) → +5 * x) zero
|]
    Util.assertNormalizesTo e "λ(zero : Natural) → +5 * +5 * +5 * zero" )

_Natural_fold_2 :: TestTree
_Natural_fold_2 = Test.Tasty.HUnit.testCase "Example #2" (do
    e <- Util.code [NeatInterpolation.text|
    λ(natural : Type)
→   λ(succ : natural → natural)
→   λ(zero : natural)
→   ./Prelude/Natural/fold +3 natural succ zero
|]
    Util.assertNormalizesTo e "λ(natural : Type) → λ(succ : natural → natural) → λ(zero : natural) → succ (succ (succ zero))" )

_Natural_isZero_0 :: TestTree
_Natural_isZero_0 = Test.Tasty.HUnit.testCase "Example #0" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Natural/isZero +2
|]
    Util.assertNormalizesTo e "False" )

_Natural_isZero_1 :: TestTree
_Natural_isZero_1 = Test.Tasty.HUnit.testCase "Example #1" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Natural/isZero +0
|]
    Util.assertNormalizesTo e "True" )

_Natural_odd_0 :: TestTree
_Natural_odd_0 = Test.Tasty.HUnit.testCase "Example #0" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Natural/odd +3
|]
    Util.assertNormalizesTo e "True" )

_Natural_odd_1 :: TestTree
_Natural_odd_1 = Test.Tasty.HUnit.testCase "Example #1" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Natural/odd +0
|]
    Util.assertNormalizesTo e "False" )

_Natural_product_0 :: TestTree
_Natural_product_0 = Test.Tasty.HUnit.testCase "Example #0" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Natural/product ([+2, +3, +5] : List Natural)
|]
    Util.assertNormalizesTo e "+30" )

_Natural_product_1 :: TestTree
_Natural_product_1 = Test.Tasty.HUnit.testCase "Example #1" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Natural/product ([] : List Natural)
|]
    Util.assertNormalizesTo e "+1" )

_Natural_show_0 :: TestTree
_Natural_show_0 = Test.Tasty.HUnit.testCase "Example #0" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Natural/show +3
|]
    Util.assertNormalizesTo e "\"+3\"" )

_Natural_show_1 :: TestTree
_Natural_show_1 = Test.Tasty.HUnit.testCase "Example #1" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Natural/show +0
|]
    Util.assertNormalizesTo e "\"+0\"" )

_Natural_sum_0 :: TestTree
_Natural_sum_0 = Test.Tasty.HUnit.testCase "Example #0" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Natural/sum ([+2, +3, +5] : List Natural)
|]
    Util.assertNormalizesTo e "+10" )

_Natural_sum_1 :: TestTree
_Natural_sum_1 = Test.Tasty.HUnit.testCase "Example #1" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Natural/sum ([] : List Natural)
|]
    Util.assertNormalizesTo e "+0" )

_Natural_toInteger_0 :: TestTree
_Natural_toInteger_0 = Test.Tasty.HUnit.testCase "Example #0" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Natural/toInteger +3
|]
    Util.assertNormalizesTo e "3" )

_Natural_toInteger_1 :: TestTree
_Natural_toInteger_1 = Test.Tasty.HUnit.testCase "Example #1" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Natural/toInteger +0
|]
    Util.assertNormalizesTo e "0" )

_Optional_build_0 :: TestTree
_Optional_build_0 = Test.Tasty.HUnit.testCase "Example #0" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Optional/build
Integer
(   λ(optional : Type)
→   λ(just : Integer → optional)
→   λ(nothing : optional)
→   just 1
)
|]
    Util.assertNormalizesTo e "[1] : Optional Integer" )

_Optional_build_1 :: TestTree
_Optional_build_1 = Test.Tasty.HUnit.testCase "Example #1" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Optional/build
Integer
(   λ(optional : Type)
→   λ(just : Integer → optional)
→   λ(nothing : optional)
→   nothing
)
|]
    Util.assertNormalizesTo e "[] : Optional Integer" )

_Optional_concat_0 :: TestTree
_Optional_concat_0 = Test.Tasty.HUnit.testCase "Example #0" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Optional/concat Integer ([[1] : Optional Integer] : Optional (Optional Integer))
|]
    Util.assertNormalizesTo e "[1] : Optional Integer" )

_Optional_concat_1 :: TestTree
_Optional_concat_1 = Test.Tasty.HUnit.testCase "Example #1" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Optional/concat Integer ([[] : Optional Integer] : Optional (Optional Integer))
|]
    Util.assertNormalizesTo e "[] : Optional Integer" )

_Optional_concat_2 :: TestTree
_Optional_concat_2 = Test.Tasty.HUnit.testCase "Example #2" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Optional/concat Integer ([] : Optional (Optional Integer))
|]
    Util.assertNormalizesTo e "[] : Optional Integer" )

_Optional_fold_0 :: TestTree
_Optional_fold_0 = Test.Tasty.HUnit.testCase "Example #0" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Optional/fold Integer ([2] : Optional Integer) Integer (λ(x : Integer) → x) 0
|]
    Util.assertNormalizesTo e "2" )

_Optional_fold_1 :: TestTree
_Optional_fold_1 = Test.Tasty.HUnit.testCase "Example #1" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Optional/fold Integer ([]  : Optional Integer) Integer (λ(x : Integer) → x) 0
|]
    Util.assertNormalizesTo e "0" )

_Optional_head_0 :: TestTree
_Optional_head_0 = Test.Tasty.HUnit.testCase "Example #0" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Optional/head
Integer
(   [[] : Optional Integer, [1] : Optional Integer, [2] : Optional Integer]
    : List (Optional Integer)
)
|]
    Util.assertNormalizesTo e "[1] : Optional Integer" )

_Optional_head_1 :: TestTree
_Optional_head_1 = Test.Tasty.HUnit.testCase "Example #1" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Optional/head
Integer
([[] : Optional Integer, [] : Optional Integer] : List (Optional Integer))
|]
    Util.assertNormalizesTo e "[] : Optional Integer" )

_Optional_head_2 :: TestTree
_Optional_head_2 = Test.Tasty.HUnit.testCase "Example #2" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Optional/head Integer ([] : List (Optional Integer))
|]
    Util.assertNormalizesTo e "[] : Optional Integer" )

_Optional_last_0 :: TestTree
_Optional_last_0 = Test.Tasty.HUnit.testCase "Example #0" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Optional/last
Integer
(   [[] : Optional Integer, [1] : Optional Integer, [2] : Optional Integer]
    : List (Optional Integer)
)
|]
    Util.assertNormalizesTo e "[2] : Optional Integer" )

_Optional_last_1 :: TestTree
_Optional_last_1 = Test.Tasty.HUnit.testCase "Example #1" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Optional/last
Integer
([[] : Optional Integer, [] : Optional Integer] : List (Optional Integer))
|]
    Util.assertNormalizesTo e "[] : Optional Integer" )

_Optional_last_2 :: TestTree
_Optional_last_2 = Test.Tasty.HUnit.testCase "Example #2" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Optional/last Integer ([] : List (Optional Integer))
|]
    Util.assertNormalizesTo e "[] : Optional Integer" )

_Optional_map_0 :: TestTree
_Optional_map_0 = Test.Tasty.HUnit.testCase "Example #0" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Optional/map Natural Bool Natural/even ([+3] : Optional Natural)
|]
    Util.assertNormalizesTo e "[False] : Optional Bool" )

_Optional_map_1 :: TestTree
_Optional_map_1 = Test.Tasty.HUnit.testCase "Example #1" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Optional/map Natural Bool Natural/even ([] : Optional Natural)
|]
    Util.assertNormalizesTo e "[] : Optional Bool" )

_Optional_toList_0 :: TestTree
_Optional_toList_0 = Test.Tasty.HUnit.testCase "Example #0" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Optional/toList Integer ([1] : Optional Integer)
|]
    Util.assertNormalizesTo e "[1] : List Integer" )

_Optional_toList_1 :: TestTree
_Optional_toList_1 = Test.Tasty.HUnit.testCase "Example #1" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Optional/toList Integer ([] : Optional Integer)
|]
    Util.assertNormalizesTo e "[] : List Integer" )

_Optional_unzip_0 :: TestTree
_Optional_unzip_0 = Test.Tasty.HUnit.testCase "Example #0" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Optional/unzip
Text
Bool
([{ _1 = "ABC", _2 = True  }] : Optional { _1 : Text, _2 : Bool })
|]
    Util.assertNormalizesTo e "{ _1 = [\"ABC\"] : Optional Text, _2 = [True] : Optional Bool }" )

_Optional_unzip_1 :: TestTree
_Optional_unzip_1 = Test.Tasty.HUnit.testCase "Example #1" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Optional/unzip Text Bool ([] : Optional { _1 : Text, _2 : Bool })
|]
    Util.assertNormalizesTo e "{ _1 = [] : Optional Text, _2 = [] : Optional Bool }" )

_Text_concat_0 :: TestTree
_Text_concat_0 = Test.Tasty.HUnit.testCase "Example #0" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Text/concat (["ABC", "DEF", "GHI"] : List Text)
|]
    Util.assertNormalizesTo e "\"ABCDEFGHI\"" )

_Text_concat_1 :: TestTree
_Text_concat_1 = Test.Tasty.HUnit.testCase "Example #1" (do
    e <- Util.code [NeatInterpolation.text|
./Prelude/Text/concat ([] : List Text)
|]
    Util.assertNormalizesTo e "\"\"" )